/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.2
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

#define SWIGPYTHON
#define SWIG_DIRECTORS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

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

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

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

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



#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG
#else
# include <Python.h>
#endif

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

/* 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 to return 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)
#define SWIG_ERROR                 (-1)
#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 temporal 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 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(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.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  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 = ((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = ((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (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

/*  Errors in SWIG */
#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 PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

#ifndef Py_TYPE
#  define Py_TYPE(op) ((op)->ob_type)
#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


/* Warning: This function will allocate a new string in Python 3,
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 */
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
  char *cstr;
  char *newstr;
  Py_ssize_t len;
  str = PyUnicode_AsUTF8String(str);
  PyBytes_AsStringAndSize(str, &cstr, &len);
  newstr = (char *) malloc(len+1);
  memcpy(newstr, cstr, len+1);
  Py_XDECREF(str);
  return newstr;
#else
  return PyString_AsString(str);
#endif
}

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
#  define SWIG_Python_str_DelForPy3(x) 
#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
}

/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
#  define PyOS_snprintf _snprintf
# else
#  define PyOS_snprintf snprintf
# endif
#endif

/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000

#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif

static PyObject *
PyString_FromFormat(const char *fmt, ...) {
  va_list ap;
  char buf[SWIG_PYBUFFER_SIZE * 2];
  int res;
  va_start(ap, fmt);
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);
  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif

/* Add PyObject_Del for old Pythons */
#if PY_VERSION_HEX < 0x01060000
# define PyObject_Del(op) PyMem_DEL((op))
#endif
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
#  define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
#  define PyObject_GenericGetAttr 0
# endif
#endif

/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
#  define Py_NotImplemented PyExc_RuntimeError
# endif
#endif

/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif

/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
#  define PySequence_Size PySequence_Length
# endif
#endif

/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
  PyObject *result = ok ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
#endif

/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intintargfunc ssizessizeargfunc;
typedef intobjargproc ssizeobjargproc;
typedef intintobjargproc ssizessizeobjargproc;
typedef getreadbufferproc readbufferproc;
typedef getwritebufferproc writebufferproc;
typedef getsegcountproc segcountproc;
typedef getcharbufferproc charbufferproc;
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
{
  long result = 0;
  PyObject *i = PyNumber_Int(x);
  if (i) {
    result = PyInt_AsLong(i);
    Py_DECREF(i);
  }
  return result;
}
#endif

#if PY_VERSION_HEX < 0x02050000
#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
#endif

#if PY_VERSION_HEX < 0x02040000
#define Py_VISIT(op)				\
  do { 						\
    if (op) {					\
      int vret = visit((op), arg);		\
      if (vret)					\
        return vret;				\
    }						\
  } while (0)
#endif

#if PY_VERSION_HEX < 0x02030000
typedef struct {
  PyTypeObject type;
  PyNumberMethods as_number;
  PyMappingMethods as_mapping;
  PySequenceMethods as_sequence;
  PyBufferProcs as_buffer;
  PyObject *name, *slots;
} PyHeapTypeObject;
#endif

#if PY_VERSION_HEX < 0x02030000
typedef destructor freefunc;
#endif

#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     (PY_MAJOR_VERSION > 3))
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
#endif

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#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;
  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) {
    char *tmp;
    PyObject *old_str = PyObject_Str(value);
    PyErr_Clear();
    Py_XINCREF(type);

    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

#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)
#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
#      define SWIG_PYTHON_USE_GIL
#    endif
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
#    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) { PyEval_RestoreThread(save); status = false; }}
         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;
  char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;


/* -----------------------------------------------------------------------------
 * Wrapper of PyInstanceMethod_New() used in Python 3
 * It is exported to the generated module, used for -fastproxy
 * ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX >= 0x03000000
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
{
  return PyInstanceMethod_New(func);
}
#else
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
{
  return NULL;
}
#endif

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

/* 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);
  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);
  Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
#else
  PyObject*   o2;
  PyObject*   o3;
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyTuple_Check(result)) {
      o2 = result;
      result = PyTuple_New(1);
      PyTuple_SET_ITEM(result, 0, o2);
    }
    o3 = PyTuple_New(1);
    PyTuple_SET_ITEM(o3, 0, obj);
    o2 = result;
    result = PySequence_Concat(o2, o3);
    Py_DECREF(o2);
    Py_DECREF(o3);
  }
  return result;
#endif
}

/* Unpack the argument tuple */

SWIGINTERN int
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) {
      int 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 {
      int i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

/* A functor is a function object with one single object argument */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
#endif

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

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

/*  How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  ifndef SWIG_PYTHON_NO_BUILD_NONE
#    ifndef SWIG_PYTHON_BUILD_NONE
#      define SWIG_PYTHON_BUILD_NONE
#    endif
#  endif
#endif

#ifdef SWIG_PYTHON_BUILD_NONE
#  ifdef Py_None
#   undef Py_None
#   define Py_None SWIG_Py_None()
#  endif
SWIGRUNTIMEINLINE PyObject * 
_SWIG_Py_None(void)
{
  PyObject *none = Py_BuildValue((char*)"");
  Py_DECREF(none);
  return none;
}
SWIGRUNTIME PyObject * 
SWIG_Py_None(void)
{
  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
  return none;
}
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  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;
  return data ? data->implicitconv : 0;
}

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;
    Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
#if (PY_VERSION_HEX < 0x02020000)
      data->newraw = 0;
#else
      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
#endif
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
#ifdef METH_O
      data->delargs = !(flags & (METH_O));
#else
      data->delargs = 0;
#endif
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

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

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

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;

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) {
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
      PyObject *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
	Py_DECREF(ofmt);
      }
      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 *
#ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject *v)
#else
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
  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 (v->next) {
# ifdef METH_NOARGS
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# else
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
# endif
# if PY_VERSION_HEX >= 0x03000000
    PyObject *joined = PyUnicode_Concat(repr, nrep);
    Py_DecRef(repr);
    Py_DecRef(nrep);
    repr = joined;
# else
    PyString_ConcatAndDel(&repr,nrep);
# endif
  }
  return repr;  
}

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;
  if( op != Py_EQ && op != Py_NE ) {
    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) {
#ifdef SWIGPYTHON_BUILTIN
  PyTypeObject *target_tp = SwigPyObject_type();
  if (PyType_IsSubtype(op->ob_type, target_tp))
    return 1;
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}

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

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;
      if (data->delargs) {
	/* we need to create a temporary object to carry the destroy operation */
	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
	res = SWIG_Python_CallFunctor(destroy, tmp);
	Py_DECREF(tmp);
      } else {
	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
	PyObject *mself = PyCFunction_GET_SELF(destroy);
	res = ((*meth)(mself, v));
      }
      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
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
  PyObject *tmp = 0;
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
  next = tmp;
#endif
  if (!SwigPyObject_Check(next)) {
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
#ifdef METH_NOARGS
SwigPyObject_next(PyObject* v)
#else
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

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

SWIGINTERN PyObject*
#ifdef METH_NOARGS
SwigPyObject_acquire(PyObject *v)
#else
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
  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 (PY_VERSION_HEX < 0x02020000)
  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#elif (PY_VERSION_HEX < 0x02050000)
  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
#else
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
#endif
    {
      return NULL;
    } 
  else
    {
      SwigPyObject *sobj = (SwigPyObject *)v;
      PyObject *obj = PyBool_FromLong(sobj->own);
      if (val) {
#ifdef METH_NOARGS
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v);
	} else {
	  SwigPyObject_disown(v);
	}
#else
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v,args);
	} else {
	  SwigPyObject_disown(v,args);
	}
#endif
      } 
      return obj;
    }
}

#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#else
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#endif

#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

  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 >= 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 */
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyObject",               /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,				    /* tp_print */
#if PY_VERSION_HEX < 0x02020000
      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
#else
      (getattrfunc)0,                       /* tp_getattr */
#endif
      (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 */
#if PY_VERSION_HEX >= 0x02020000
      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 */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version */
#endif
#ifdef COUNT_ALLOCS
      0,0,0,0                               /* tp_alloc -> tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpyobject_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
#endif
  }
  return &swigpyobject_type;
}

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;
  }
  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 int
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
  char result[SWIG_BUFFER_SIZE];
  fputs("<Swig Packed ", fp); 
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    fputs("at ", fp); 
    fputs(result, fp); 
  }
  fputs(v->ty->name,fp); 
  fputs(">", fp);
  return 0; 
}
  
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((char *)v->pack, (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) {
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}

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

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
      /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      (char *)"SwigPyPacked",               /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      (printfunc)SwigPyPacked_print,        /* tp_print */
      (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 */
#if PY_VERSION_HEX >= 0x02020000
      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 */
#endif
#if PY_VERSION_HEX >= 0x02030000
      0,                                    /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
      0,                                    /* tp_version */
#endif
#ifdef COUNT_ALLOCS
      0,0,0,0                               /* tp_alloc -> tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
#if PY_VERSION_HEX < 0x02020000
    swigpypacked_type.ob_type = &PyType_Type;
#else
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
#endif
  }
  return &swigpypacked_type;
}

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

SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
    return SWIG_Python_str_FromChar("this");
}

static PyObject *swig_this = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (swig_this == NULL)
    swig_this = _SWIG_This();
  return swig_this;
}

/* #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)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
  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) {
	Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    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 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 (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 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);		    
                }
              }
            }
            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;
    
    /* here we get the method pointer for callbacks */
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    if (!desc) 
      return SWIG_ERROR;
    if (ty) {
      swig_cast_info *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;
      }
    } else {
      *ptr = vptr;
    }
    return SWIG_OK;
  }
}

/* Convert a packed value 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)
{
#if (PY_VERSION_HEX >= 0x02020000)
  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;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      PyObject *key = SWIG_This();
      PyObject_SetAttr(inst, key, swig_this);
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    if (inst) {
      PyObject_SetAttr(inst, SWIG_This(), swig_this);
      Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
  PyObject *inst = 0;
  PyObject *dict = PyDict_New();
  if (dict) {
    PyDict_SetItem(dict, SWIG_This(), swig_this);
    inst = PyInstance_NewRaw(data->newargs, dict);
    Py_DECREF(dict);
  }
  return (PyObject *) inst;
#else
  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
  if (inst == NULL) {
    return NULL;
  }
  inst->in_class = (PyClassObject *)data->newargs;
  Py_INCREF(inst->in_class);
  inst->in_dict = PyDict_New();
  if (inst->in_dict == NULL) {
    Py_DECREF(inst);
    return NULL;
  }
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
  inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
  PyObject_GC_Init(inst);
#endif
  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
  return (PyObject *) inst;
#endif
#endif
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 PyObject **dictptr = _PyObject_GetDictPtr(inst);
 if (dictptr != NULL) {
   dict = *dictptr;
   if (dict == NULL) {
     dict = PyDict_New();
     *dictptr = dict;
   }
   PyDict_SetItem(dict, SWIG_This(), swig_this);
   return;
 }
#endif
 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
 PyDict_SetItem(dict, SWIG_This(), swig_this);
 Py_DECREF(dict);
} 


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) {
      SwigPyObject_append((PyObject*) sthis, obj[1]);
    } else {
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
    }
    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) {
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
      newobj->dict = 0;
#endif
      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);
    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

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

#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
   is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
  PyObject *dict;
  if (!PyModule_Check(m)) {
    PyErr_SetString(PyExc_TypeError,
		    "PyModule_AddObject() needs module as first arg");
    return SWIG_ERROR;
  }
  if (!o) {
    PyErr_SetString(PyExc_TypeError,
		    "PyModule_AddObject() needs non-NULL value");
    return SWIG_ERROR;
  }
  
  dict = PyModule_GetDict(m);
  if (dict == NULL) {
    /* Internal error -- modules must have a dict! */
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
		 PyModule_GetName(m));
    return SWIG_ERROR;
  }
  if (PyDict_SetItemString(dict, name, o))
    return SWIG_ERROR;
  Py_DECREF(o);
  return SWIG_OK;
}
#endif

SWIGRUNTIME void
#ifdef SWIGPY_USE_CAPSULE
SWIG_Python_DestroyModule(PyObject *obj)
#else
SWIG_Python_DestroyModule(void *vptr)
#endif
{
#ifdef SWIGPY_USE_CAPSULE
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
#else
  swig_module_info *swig_module = (swig_module_info *) vptr;
#endif
  swig_type_info **types = swig_module->types;
  size_t i;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  swig_this = 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((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
#ifdef SWIGPY_USE_CAPSULE
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#else
  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
#endif
}

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
  return cache;
}

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) {
#ifdef SWIGPY_USE_CAPSULE
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
#else
    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
#endif
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
#ifdef SWIGPY_USE_CAPSULE
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
#else
      obj = PyCObject_FromVoidPtr(descriptor, NULL);
#endif
      PyDict_SetItem(cache, key, obj);
      Py_DECREF(obj);
    }
  }
  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) {
      char *tmp;
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
      } else {
	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
      }
      SWIG_Python_str_DelForPy3(tmp);
      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)
{
  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      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
          SWIG_Python_str_DelForPy3(cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_XDECREF(str);
	return;
      }
    }   
    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();
#if SWIG_POINTER_EXCEPTION
    if (flags) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
#endif
  }
  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 {
    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;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  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) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 


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


/*
  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, what());
      }
      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);
    }
  };

  /* unknown exception handler  */
  class UnknownExceptionHandler {
#ifdef SWIG_DIRECTOR_UEH
    static void handler() {
      try {
        throw;
      } catch (DirectorException& e) {
        std::cerr << "SWIG Director exception caught:" << std::endl
                  << e.what() << std::endl;
      } catch (std::exception& e) {
        std::cerr << "std::exception caught: "<< e.what() << std::endl;
      } catch (...) {
        std::cerr << "Unknown exception caught." << std::endl;
      }

      std::cerr << std::endl
                << "Python interpreter traceback:" << std::endl;
      PyErr_Print();
      std::cerr << std::endl;

      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
                << std::endl
                << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
      throw;
    }

  public:

    std::unexpected_handler old;
    UnknownExceptionHandler(std::unexpected_handler nh = handler) {
      old = std::set_unexpected(nh);
    }

    ~UnknownExceptionHandler() {
      std::set_unexpected(old);
    }
#endif
  };

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


#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
# include "pythread.h"
  class Guard {
    PyThread_type_lock &mutex_;

  public:
    Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
      PyThread_acquire_lock(mutex_, WAIT_LOCK);
    }

    ~Guard() {
      PyThread_release_lock(mutex_);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

  /* 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;
        Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object, optionally taking ownership */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
      swig_incref();
    }

    /* 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) {
        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;
#ifdef __THREAD__
    static PyThread_type_lock swig_mutex_own;
#endif

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

#ifdef __THREAD__
  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
#endif
}

#endif

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

#define SWIGTYPE_p_FILE swig_types[0]
#define SWIGTYPE_p_FL_CHART_ENTRY swig_types[1]
#define SWIGTYPE_p_Fl swig_types[2]
#define SWIGTYPE_p_Fl_Adjuster swig_types[3]
#define SWIGTYPE_p_Fl_BMP_Image swig_types[4]
#define SWIGTYPE_p_Fl_Bitmap swig_types[5]
#define SWIGTYPE_p_Fl_Box swig_types[6]
#define SWIGTYPE_p_Fl_Browser swig_types[7]
#define SWIGTYPE_p_Fl_Browser_ swig_types[8]
#define SWIGTYPE_p_Fl_Button swig_types[9]
#define SWIGTYPE_p_Fl_Chart swig_types[10]
#define SWIGTYPE_p_Fl_Check_Browser swig_types[11]
#define SWIGTYPE_p_Fl_Check_Button swig_types[12]
#define SWIGTYPE_p_Fl_Choice swig_types[13]
#define SWIGTYPE_p_Fl_Clock swig_types[14]
#define SWIGTYPE_p_Fl_Clock_Output swig_types[15]
#define SWIGTYPE_p_Fl_Color_Chooser swig_types[16]
#define SWIGTYPE_p_Fl_Counter swig_types[17]
#define SWIGTYPE_p_Fl_Dial swig_types[18]
#define SWIGTYPE_p_Fl_Double_Window swig_types[19]
#define SWIGTYPE_p_Fl_End swig_types[20]
#define SWIGTYPE_p_Fl_File_Browser swig_types[21]
#define SWIGTYPE_p_Fl_File_Chooser swig_types[22]
#define SWIGTYPE_p_Fl_File_Icon swig_types[23]
#define SWIGTYPE_p_Fl_File_Input swig_types[24]
#define SWIGTYPE_p_Fl_Fill_Dial swig_types[25]
#define SWIGTYPE_p_Fl_Fill_Slider swig_types[26]
#define SWIGTYPE_p_Fl_Float_Input swig_types[27]
#define SWIGTYPE_p_Fl_FormsBitmap swig_types[28]
#define SWIGTYPE_p_Fl_FormsPixmap swig_types[29]
#define SWIGTYPE_p_Fl_Free swig_types[30]
#define SWIGTYPE_p_Fl_GIF_Image swig_types[31]
#define SWIGTYPE_p_Fl_Gl_Window swig_types[32]
#define SWIGTYPE_p_Fl_Graphics_Driver swig_types[33]
#define SWIGTYPE_p_Fl_Group swig_types[34]
#define SWIGTYPE_p_Fl_Help_Block swig_types[35]
#define SWIGTYPE_p_Fl_Help_Dialog swig_types[36]
#define SWIGTYPE_p_Fl_Help_Font_Stack swig_types[37]
#define SWIGTYPE_p_Fl_Help_Font_Style swig_types[38]
#define SWIGTYPE_p_Fl_Help_Link swig_types[39]
#define SWIGTYPE_p_Fl_Help_Target swig_types[40]
#define SWIGTYPE_p_Fl_Help_View swig_types[41]
#define SWIGTYPE_p_Fl_Hold_Browser swig_types[42]
#define SWIGTYPE_p_Fl_Hor_Fill_Slider swig_types[43]
#define SWIGTYPE_p_Fl_Hor_Nice_Slider swig_types[44]
#define SWIGTYPE_p_Fl_Hor_Slider swig_types[45]
#define SWIGTYPE_p_Fl_Hor_Value_Slider swig_types[46]
#define SWIGTYPE_p_Fl_Image swig_types[47]
#define SWIGTYPE_p_Fl_Input swig_types[48]
#define SWIGTYPE_p_Fl_Input_ swig_types[49]
#define SWIGTYPE_p_Fl_Input_Choice swig_types[50]
#define SWIGTYPE_p_Fl_Int_Input swig_types[51]
#define SWIGTYPE_p_Fl_JPEG_Image swig_types[52]
#define SWIGTYPE_p_Fl_Label swig_types[53]
#define SWIGTYPE_p_Fl_Light_Button swig_types[54]
#define SWIGTYPE_p_Fl_Line_Dial swig_types[55]
#define SWIGTYPE_p_Fl_Menu_ swig_types[56]
#define SWIGTYPE_p_Fl_Menu_Bar swig_types[57]
#define SWIGTYPE_p_Fl_Menu_Button swig_types[58]
#define SWIGTYPE_p_Fl_Menu_Item swig_types[59]
#define SWIGTYPE_p_Fl_Menu_Window swig_types[60]
#define SWIGTYPE_p_Fl_Multi_Browser swig_types[61]
#define SWIGTYPE_p_Fl_Multi_Label swig_types[62]
#define SWIGTYPE_p_Fl_Multiline_Input swig_types[63]
#define SWIGTYPE_p_Fl_Multiline_Output swig_types[64]
#define SWIGTYPE_p_Fl_Nice_Slider swig_types[65]
#define SWIGTYPE_p_Fl_Option swig_types[66]
#define SWIGTYPE_p_Fl_Output swig_types[67]
#define SWIGTYPE_p_Fl_Overlay_Window swig_types[68]
#define SWIGTYPE_p_Fl_PNG_Image swig_types[69]
#define SWIGTYPE_p_Fl_PNM_Image swig_types[70]
#define SWIGTYPE_p_Fl_Pack swig_types[71]
#define SWIGTYPE_p_Fl_Paged_Device swig_types[72]
#define SWIGTYPE_p_Fl_Pixmap swig_types[73]
#define SWIGTYPE_p_Fl_Positioner swig_types[74]
#define SWIGTYPE_p_Fl_Preferences swig_types[75]
#define SWIGTYPE_p_Fl_Printer swig_types[76]
#define SWIGTYPE_p_Fl_Progress swig_types[77]
#define SWIGTYPE_p_Fl_RGB_Image swig_types[78]
#define SWIGTYPE_p_Fl_Radio_Button swig_types[79]
#define SWIGTYPE_p_Fl_Radio_Light_Button swig_types[80]
#define SWIGTYPE_p_Fl_Radio_Round_Button swig_types[81]
#define SWIGTYPE_p_Fl_Region swig_types[82]
#define SWIGTYPE_p_Fl_Repeat_Button swig_types[83]
#define SWIGTYPE_p_Fl_Return_Button swig_types[84]
#define SWIGTYPE_p_Fl_Roller swig_types[85]
#define SWIGTYPE_p_Fl_Round_Button swig_types[86]
#define SWIGTYPE_p_Fl_Round_Clock swig_types[87]
#define SWIGTYPE_p_Fl_Scroll swig_types[88]
#define SWIGTYPE_p_Fl_Scrollbar swig_types[89]
#define SWIGTYPE_p_Fl_Secret_Input swig_types[90]
#define SWIGTYPE_p_Fl_Select_Browser swig_types[91]
#define SWIGTYPE_p_Fl_Shared_Image swig_types[92]
#define SWIGTYPE_p_Fl_Simple_Counter swig_types[93]
#define SWIGTYPE_p_Fl_Single_Window swig_types[94]
#define SWIGTYPE_p_Fl_Slider swig_types[95]
#define SWIGTYPE_p_Fl_Spinner swig_types[96]
#define SWIGTYPE_p_Fl_Table swig_types[97]
#define SWIGTYPE_p_Fl_Table_Row swig_types[98]
#define SWIGTYPE_p_Fl_Tabs swig_types[99]
#define SWIGTYPE_p_Fl_Text_Buffer swig_types[100]
#define SWIGTYPE_p_Fl_Text_Display swig_types[101]
#define SWIGTYPE_p_Fl_Text_Display__Style_Table_Entry swig_types[102]
#define SWIGTYPE_p_Fl_Text_Editor swig_types[103]
#define SWIGTYPE_p_Fl_Text_Selection swig_types[104]
#define SWIGTYPE_p_Fl_Tile swig_types[105]
#define SWIGTYPE_p_Fl_Tiled_Image swig_types[106]
#define SWIGTYPE_p_Fl_Timer swig_types[107]
#define SWIGTYPE_p_Fl_Toggle_Button swig_types[108]
#define SWIGTYPE_p_Fl_Tooltip swig_types[109]
#define SWIGTYPE_p_Fl_Tree swig_types[110]
#define SWIGTYPE_p_Fl_Tree_Item swig_types[111]
#define SWIGTYPE_p_Fl_Tree_Item_Array swig_types[112]
#define SWIGTYPE_p_Fl_Tree_Prefs swig_types[113]
#define SWIGTYPE_p_Fl_Valuator swig_types[114]
#define SWIGTYPE_p_Fl_Value_Input swig_types[115]
#define SWIGTYPE_p_Fl_Value_Output swig_types[116]
#define SWIGTYPE_p_Fl_Value_Slider swig_types[117]
#define SWIGTYPE_p_Fl_Widget swig_types[118]
#define SWIGTYPE_p_Fl_Widget_Tracker swig_types[119]
#define SWIGTYPE_p_Fl_Window swig_types[120]
#define SWIGTYPE_p_Fl_Wizard swig_types[121]
#define SWIGTYPE_p_Fl_XBM_Image swig_types[122]
#define SWIGTYPE_p_Fl_XPM_Image swig_types[123]
#define SWIGTYPE_p_Flcc_HueBox swig_types[124]
#define SWIGTYPE_p_Flcc_ValueBox swig_types[125]
#define SWIGTYPE_p_Flcc_Value_Input swig_types[126]
#define SWIGTYPE_p_ListSelect swig_types[127]
#define SWIGTYPE_p_Style_Table_Entry swig_types[128]
#define SWIGTYPE_p_char swig_types[129]
#define SWIGTYPE_p_double swig_types[130]
#define SWIGTYPE_p_f___void swig_types[131]
#define SWIGTYPE_p_f_int_int_int_int_p_q_const__char_p_void__void swig_types[132]
#define SWIGTYPE_p_f_int_int_int_int_unsigned_int__void swig_types[133]
#define SWIGTYPE_p_f_int_int_p_void__void swig_types[134]
#define SWIGTYPE_p_f_int_p_Fl_Text_Editor__int swig_types[135]
#define SWIGTYPE_p_f_int_p_Fl_Window__int swig_types[136]
#define SWIGTYPE_p_f_int_p_p_char_r_int__int swig_types[137]
#define SWIGTYPE_p_f_int_p_void__void swig_types[138]
#define SWIGTYPE_p_f_p_Fl_File_Chooser_p_void__void swig_types[139]
#define SWIGTYPE_p_f_p_Fl_Widget__void swig_types[140]
#define SWIGTYPE_p_f_p_Fl_Widget_int_float_float_char__int swig_types[141]
#define SWIGTYPE_p_f_p_Fl_Widget_long__void swig_types[142]
#define SWIGTYPE_p_f_p_Fl_Widget_p_q_const__char__p_char swig_types[143]
#define SWIGTYPE_p_f_p_Fl_Widget_p_void__void swig_types[144]
#define SWIGTYPE_p_f_p_Fl_Window_p_void__void swig_types[145]
#define SWIGTYPE_p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void swig_types[146]
#define SWIGTYPE_p_f_p_q_const__Fl_Label_r_int_r_int__void swig_types[147]
#define SWIGTYPE_p_f_p_q_const__char__void swig_types[148]
#define SWIGTYPE_p_f_p_q_const__char_int_int_int__void swig_types[149]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_BMP_Image swig_types[150]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Bitmap swig_types[151]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_GIF_Image swig_types[152]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Image swig_types[153]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_JPEG_Image swig_types[154]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_PNG_Image swig_types[155]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_PNM_Image swig_types[156]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Pixmap swig_types[157]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_RGB_Image swig_types[158]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Shared_Image swig_types[159]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_Tiled_Image swig_types[160]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_XBM_Image swig_types[161]
#define SWIGTYPE_p_f_p_q_const__char_p_uchar_int__p_Fl_XPM_Image swig_types[162]
#define SWIGTYPE_p_f_p_q_const__char_v_______void swig_types[163]
#define SWIGTYPE_p_f_p_void__void swig_types[164]
#define SWIGTYPE_p_f_p_void_int_int_int_int__void swig_types[165]
#define SWIGTYPE_p_f_p_void_p_void__int swig_types[166]
#define SWIGTYPE_p_f_unsigned_int__void swig_types[167]
#define SWIGTYPE_p_float swig_types[168]
#define SWIGTYPE_p_int swig_types[169]
#define SWIGTYPE_p_long swig_types[170]
#define SWIGTYPE_p_p_Fl_Adjuster swig_types[171]
#define SWIGTYPE_p_p_Fl_BMP_Image swig_types[172]
#define SWIGTYPE_p_p_Fl_Box swig_types[173]
#define SWIGTYPE_p_p_Fl_Browser swig_types[174]
#define SWIGTYPE_p_p_Fl_Browser_ swig_types[175]
#define SWIGTYPE_p_p_Fl_Button swig_types[176]
#define SWIGTYPE_p_p_Fl_Chart swig_types[177]
#define SWIGTYPE_p_p_Fl_Check_Browser swig_types[178]
#define SWIGTYPE_p_p_Fl_Check_Button swig_types[179]
#define SWIGTYPE_p_p_Fl_Choice swig_types[180]
#define SWIGTYPE_p_p_Fl_Clock swig_types[181]
#define SWIGTYPE_p_p_Fl_Clock_Output swig_types[182]
#define SWIGTYPE_p_p_Fl_Color_Chooser swig_types[183]
#define SWIGTYPE_p_p_Fl_Counter swig_types[184]
#define SWIGTYPE_p_p_Fl_Dial swig_types[185]
#define SWIGTYPE_p_p_Fl_Double_Window swig_types[186]
#define SWIGTYPE_p_p_Fl_File_Browser swig_types[187]
#define SWIGTYPE_p_p_Fl_File_Input swig_types[188]
#define SWIGTYPE_p_p_Fl_Fill_Dial swig_types[189]
#define SWIGTYPE_p_p_Fl_Fill_Slider swig_types[190]
#define SWIGTYPE_p_p_Fl_Float_Input swig_types[191]
#define SWIGTYPE_p_p_Fl_FormsBitmap swig_types[192]
#define SWIGTYPE_p_p_Fl_FormsPixmap swig_types[193]
#define SWIGTYPE_p_p_Fl_Free swig_types[194]
#define SWIGTYPE_p_p_Fl_Gl_Window swig_types[195]
#define SWIGTYPE_p_p_Fl_Group swig_types[196]
#define SWIGTYPE_p_p_Fl_Help_View swig_types[197]
#define SWIGTYPE_p_p_Fl_Hold_Browser swig_types[198]
#define SWIGTYPE_p_p_Fl_Hor_Fill_Slider swig_types[199]
#define SWIGTYPE_p_p_Fl_Hor_Nice_Slider swig_types[200]
#define SWIGTYPE_p_p_Fl_Hor_Slider swig_types[201]
#define SWIGTYPE_p_p_Fl_Hor_Value_Slider swig_types[202]
#define SWIGTYPE_p_p_Fl_Input swig_types[203]
#define SWIGTYPE_p_p_Fl_Input_ swig_types[204]
#define SWIGTYPE_p_p_Fl_Input_Choice swig_types[205]
#define SWIGTYPE_p_p_Fl_Int_Input swig_types[206]
#define SWIGTYPE_p_p_Fl_JPEG_Image swig_types[207]
#define SWIGTYPE_p_p_Fl_Light_Button swig_types[208]
#define SWIGTYPE_p_p_Fl_Line_Dial swig_types[209]
#define SWIGTYPE_p_p_Fl_Menu_ swig_types[210]
#define SWIGTYPE_p_p_Fl_Menu_Bar swig_types[211]
#define SWIGTYPE_p_p_Fl_Menu_Button swig_types[212]
#define SWIGTYPE_p_p_Fl_Menu_Window swig_types[213]
#define SWIGTYPE_p_p_Fl_Multi_Browser swig_types[214]
#define SWIGTYPE_p_p_Fl_Multiline_Input swig_types[215]
#define SWIGTYPE_p_p_Fl_Multiline_Output swig_types[216]
#define SWIGTYPE_p_p_Fl_Nice_Slider swig_types[217]
#define SWIGTYPE_p_p_Fl_Output swig_types[218]
#define SWIGTYPE_p_p_Fl_Overlay_Window swig_types[219]
#define SWIGTYPE_p_p_Fl_PNG_Image swig_types[220]
#define SWIGTYPE_p_p_Fl_PNM_Image swig_types[221]
#define SWIGTYPE_p_p_Fl_Pack swig_types[222]
#define SWIGTYPE_p_p_Fl_Positioner swig_types[223]
#define SWIGTYPE_p_p_Fl_Progress swig_types[224]
#define SWIGTYPE_p_p_Fl_RGB_Image swig_types[225]
#define SWIGTYPE_p_p_Fl_Radio_Button swig_types[226]
#define SWIGTYPE_p_p_Fl_Radio_Light_Button swig_types[227]
#define SWIGTYPE_p_p_Fl_Radio_Round_Button swig_types[228]
#define SWIGTYPE_p_p_Fl_Repeat_Button swig_types[229]
#define SWIGTYPE_p_p_Fl_Return_Button swig_types[230]
#define SWIGTYPE_p_p_Fl_Roller swig_types[231]
#define SWIGTYPE_p_p_Fl_Round_Button swig_types[232]
#define SWIGTYPE_p_p_Fl_Round_Clock swig_types[233]
#define SWIGTYPE_p_p_Fl_Scroll swig_types[234]
#define SWIGTYPE_p_p_Fl_Scrollbar swig_types[235]
#define SWIGTYPE_p_p_Fl_Secret_Input swig_types[236]
#define SWIGTYPE_p_p_Fl_Select_Browser swig_types[237]
#define SWIGTYPE_p_p_Fl_Shared_Image swig_types[238]
#define SWIGTYPE_p_p_Fl_Simple_Counter swig_types[239]
#define SWIGTYPE_p_p_Fl_Single_Window swig_types[240]
#define SWIGTYPE_p_p_Fl_Slider swig_types[241]
#define SWIGTYPE_p_p_Fl_Spinner swig_types[242]
#define SWIGTYPE_p_p_Fl_Table swig_types[243]
#define SWIGTYPE_p_p_Fl_Table_Row swig_types[244]
#define SWIGTYPE_p_p_Fl_Tabs swig_types[245]
#define SWIGTYPE_p_p_Fl_Text_Display swig_types[246]
#define SWIGTYPE_p_p_Fl_Text_Editor swig_types[247]
#define SWIGTYPE_p_p_Fl_Tile swig_types[248]
#define SWIGTYPE_p_p_Fl_Timer swig_types[249]
#define SWIGTYPE_p_p_Fl_Toggle_Button swig_types[250]
#define SWIGTYPE_p_p_Fl_Tree swig_types[251]
#define SWIGTYPE_p_p_Fl_Valuator swig_types[252]
#define SWIGTYPE_p_p_Fl_Value_Input swig_types[253]
#define SWIGTYPE_p_p_Fl_Value_Output swig_types[254]
#define SWIGTYPE_p_p_Fl_Value_Slider swig_types[255]
#define SWIGTYPE_p_p_Fl_Widget swig_types[256]
#define SWIGTYPE_p_p_Fl_Window swig_types[257]
#define SWIGTYPE_p_p_Fl_Wizard swig_types[258]
#define SWIGTYPE_p_p_Flcc_HueBox swig_types[259]
#define SWIGTYPE_p_p_Flcc_ValueBox swig_types[260]
#define SWIGTYPE_p_p_Flcc_Value_Input swig_types[261]
#define SWIGTYPE_p_p_ListSelect swig_types[262]
#define SWIGTYPE_p_p_char swig_types[263]
#define SWIGTYPE_p_p_p_dirent swig_types[264]
#define SWIGTYPE_p_short swig_types[265]
#define SWIGTYPE_p_unsigned_char swig_types[266]
#define SWIGTYPE_p_unsigned_int swig_types[267]
#define SWIGTYPE_p_unsigned_long swig_types[268]
#define SWIGTYPE_p_unsigned_short swig_types[269]
#define SWIGTYPE_p_void swig_types[270]
#define SWIGTYPE_p_wchar_t swig_types[271]
static swig_type_info *swig_types[273];
static swig_module_info swig_module = {swig_types, 272, 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) -------- */

#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
#  error "This python version requires swig to be run with the '-classic' option"
# endif
#endif
#if (PY_VERSION_HEX <= 0x02020000)
# error "This python version requires swig to be run with the '-nomodern' option"
#endif
#if (PY_VERSION_HEX <= 0x02020000)
# error "This python version requires swig to be run with the '-nomodernargs' option"
#endif

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

#else
#  define SWIG_init    init_fltk

#endif
#define SWIG_name    "_fltk"

#define SWIGVERSION 0x030002 
#define SWIG_VERSION SWIGVERSION


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


#include <stdexcept>


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

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

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      Py_XINCREF(_obj);      
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        Py_XINCREF(_obj);
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      Py_XDECREF(_obj);
    }
    
    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)
    {
      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/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;
  } else if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } 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 = floor(x);
   double cx = ceil(x);
   double 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 (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#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));
      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 = static_cast< 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();
#if PY_VERSION_HEX >= 0x03000000
      {
        long v = PyLong_AsLong(obj);
        if (!PyErr_Occurred()) {
          if (v < 0) {
            return SWIG_OverflowError;
          }
        } else {
          PyErr_Clear();
        }
      }
#endif
    }
  }
#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));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


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


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


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


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


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


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


#include "FL/Fl_Image.H"


  #define SWIG_From_double   PyFloat_FromDouble 


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


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  return res;
}


  #define SWIG_From_long   PyLong_FromLong 


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


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
  return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
}


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


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

  //static PyObject *my_pycallback = NULL;
  static void 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 =  PyEval_CallObject(func, arglist);
   
      //Py_XDECREF(arglist);                           // Trash arglist
      Py_XDECREF(result);
      if (PyErr_Occurred())
	{
	  PyErr_Print();
	}
   
      return /*void*/;
    }
  

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


SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
  if (PyUnicode_Check(obj))
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
#if PY_VERSION_HEX>=0x03000000
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    PyBytes_AsStringAndSize(obj, &cstr, &len);
    if(alloc) *alloc = SWIG_NEWOBJ;
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	/* 
	   In python the user should not be able to modify the inner
	   string representation. To warranty that, if you define
	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
	   buffer is always returned.

	   The default behavior is just to return the pointer value,
	   so, be careful.
	*/ 
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
	if (*alloc != SWIG_OLDOBJ) 
#else
	if (*alloc == SWIG_NEWOBJ) 
#endif
	  {
	    *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
	    *alloc = SWIG_NEWOBJ;
	  }
	else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
        #if PY_VERSION_HEX>=0x03000000
        assert(0); /* Should never reach here in Python 3 */
        #endif
	*cptr = SWIG_Python_str_AsChar(obj);
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000
    Py_XDECREF(obj);
#endif
    return SWIG_OK;
  } else {
    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;
}





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(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if PY_VERSION_HEX >= 0x03010000
      return PyUnicode_DecodeUTF8(carray, static_cast< int >(size), "surrogateescape");
#else
      return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< int >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


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


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

SWIGINTERN void Fl_Widget_draw_label__SWIG_3(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_5(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(PythonCallBack, (void *)cb);

    
    }
SWIGINTERN void Fl_Widget_user_data__SWIG_2(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 {
	cb->data = PyData;
      }
    
    }
SWIGINTERN PyObject *Fl_Widget_user_data__SWIG_3(Fl_Widget *self){
    PyObject *obj = 0;
    CallbackStruct *cb = (CallbackStruct*)self->user_data();
    if (cb) {
      if (cb->data) {
	obj = (PyObject*)cb->data;
      }
    }

    //Py_XDECREF(obj);
    Py_XINCREF(obj);
    return obj;
  }

#include "FL/Fl_Group.H"


#include "FL/Fl_Browser_.H"

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

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

       int 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 int Fl_File_Browser_load_new(Fl_File_Browser *self,PyObject *dObj,PyObject *sObj){
    //char *directory=PyString_AsString(dObj);
    char *directory=SWIG_Python_str_AsChar(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 = static_cast< short >(v);
    }
  }  
  return res;
}


#include "FL/Fl_File_Chooser.H"


#include "CallbackStruct.h"

static void PythonCallBack(Fl_File_Chooser *widget, void *clientdata)
{
   PyObject *func, *arglist;
   PyObject *result;
   PyObject *obj;

   func = (PyObject *)( ((CallbackStruct *)clientdata)->func);
   // the parent widget
   obj = (PyObject *)( ((CallbackStruct *)clientdata)->widget);
   //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 =  PyEval_CallObject(func, arglist);
   
   Py_DECREF(arglist);                           // Trash arglist
   Py_XDECREF(result);
   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;
	cb = new CallbackStruct( PyFunc, PyData, PyWidget );

	Py_INCREF(PyFunc);			/* Add a reference to new callback */
        Py_XINCREF(PyData);
        Py_XINCREF(PyWidget);
	
	self->callback(PythonCallBack, (void *)cb);
    
}

#include "FL/Fl.H"


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

SWIGINTERN void Fl_cond_lock(){
#ifdef DO_NOT_USE_THREADS
      fprintf(stderr, "Warning: Fl::lock() not supported!\n");
#else
      Fl::lock();
#endif
    }
SWIGINTERN void Fl_cond_unlock(){
#ifdef DO_NOT_USE_THREADS
      fprintf(stderr, "Warning: Fl::unlock() not supported!\n");
#else
      Fl::unlock();
#endif
    }
SWIGINTERN void Fl_cond_awake__SWIG_1(void *message=0){
#ifdef DO_NOT_USE_THREADS
      fprintf(stderr, "Warning: Fl::awake() not supported!\n");
#else
      Fl::awake(message);
#endif
    }
SWIGINTERN void Fl_cond_thread_message(){
#ifdef DO_NOT_USE_THREADS
      fprintf(stderr, "Warning: Fl::thread_message() not supported!\n");
#else
      Fl::thread_message();
#endif
    }

// called by FLTK when idle
PyObject *registeredDoIDle = 0;
void pyFLTK_idleCallback(void *data)
{
        PyObject *arglist;
        PyObject *result;
        arglist = Py_BuildValue("()");       // Build argument list
        result = PyEval_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 = PyEval_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
    {
      //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;
	//for (l = py_timeout_funcs, p = 0; l && l->handle->func != func; p = l, l = l->next);
	for (l = py_timeout_funcs, p = 0; l != NULL ; p = l, l = l->next )
	{
	  if( ( PyObject_RichCompareBool( l->handle->func, func, Py_EQ ) == 1 ) &&
	      ( PyObject_RichCompareBool( l->handle->data, data, Py_EQ ) == 1 ) )
	    //	found a match
	    {
	      // 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);
	    


	      //if (l) {
	      // 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);

	      // And free the record...
	      delete l;
	    }
	}
      }
    }
  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);
         PyEval_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;
     PyObject *func = 0;
     PyObject *data = 0;

     PyArg_ParseTuple( args, "iO|O", &fd, &func, &data);
     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
	   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 = PyEval_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 = PyEval_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/dirent.h"


#include "FL/filename.H"


#include "FL/Fl_Valuator.H"


#include "FL/Fl_Adjuster.H"


#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;
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    Py_BEGIN_ALLOW_THREADS;
    status = fl_ask("%s", text);
    Py_END_ALLOW_THREADS;
    #pragma GCC diagnostic pop
    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"
  

#include "FL/Fl_Button.H"


#include "FL/Fl_Chart.H"


#include "FL/Fl_Check_Browser.H"


#include "FL/Fl_Light_Button.H"


#include "FL/Fl_Check_Button.H"


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

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

		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 *)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_Choice.H"


#include "FL/Fl_Clock.H"


#include "FL/Fl_Value_Input.H"


#include "FL/Fl_Color_Chooser.H"


#include "FL/Fl_Counter.H"


#include "FL/Fl_Dial.H"


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


#include "FL/Fl_Window.H"

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)) {
      int 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] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      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] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/Fl_Double_Window.H"

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)) {
      int 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] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      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] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/fl_draw.H"


#include "FL/Fl_Export.H"


#include "FL/Fl_Input_.H"


#include "FL/Fl_Input.H"


#include "FL/Fl_File_Input.H"


#include "FL/Fl_Fill_Dial.H"


#include "FL/Fl_Slider.H"


#include "FL/Fl_Fill_Slider.H"


#include "FL/Fl_Float_Input.H"


#include "FL/Fl_FormsBitmap.H"


#include "FL/Fl_FormsPixmap.H"


#include "FL/Fl_Free.H"


#include "FL/Fl_Pixmap.H"


#include "FL/Fl_GIF_Image.H"


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

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)) {
      int 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] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      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] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      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 =  PyEval_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_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"


#include "FL/Fl_Hor_Fill_Slider.H"


#include "FL/Fl_Hor_Nice_Slider.H"


#include "FL/Fl_Hor_Slider.H"


#include "FL/Fl_Value_Slider.H"


#include "FL/Fl_Hor_Value_Slider.H"


#include "FL/Fl_Int_Input.H"


#include "FL/Fl_Input_Choice.H"


#include "FL/Fl_JPEG_Image.H"


#include "FL/Fl_Line_Dial.H"


#include "FL/Fl_Menu_Bar.H"


#include "FL/Fl_Menu_Button.H"


#include "FL/Fl_Menu_Item.H"
#include <CallbackStruct.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__SWIG_2(Fl_Menu_Item *self){
	CallbackStruct *cb = (CallbackStruct*)self->user_data_;
	PyObject *o = Py_BuildValue("O", cb->data);
	return o;
    }

#include "FL/Fl_Single_Window.H"

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)) {
      int 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] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      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] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/Fl_Menu_Window.H"


#include "FL/fl_message.H"


#include "FL/Fl_Multiline_Input.H"


#include "FL/Fl_Output.H"


#include "FL/Fl_Multiline_Output.H"


#include "FL/Fl_Multi_Browser.H"


#include "FL/Fl_Multi_Label.H"


#include "FL/Fl_Nice_Slider.H"


#include "FL/Fl_Overlay_Window.H"

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)) {
      int 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] = PyString_AsString(PyList_GetItem(count,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      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] = PyString_AsString(PyList_GetItem(data,i));
	else {
	  PyErr_SetString(PyExc_TypeError,"list must contain strings");
	  free(tmp);
	  return;
	}
      }
      tmp[i] = 0;
      self->show(size, tmp);
      free(tmp);
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      self->show();
    }
		
  }
}

#include "FL/Fl_Pack.H"


#include "FL/Fl_PNG_Image.H"


#include "FL/Fl_PNM_Image.H"


#include "FL/Fl_Positioner.H"


#include "FL/Fl_Preferences.H"


#include "FL/Fl_Progress.H"


#include "FL/Fl_Radio_Button.H"


#include "FL/Fl_Radio_Light_Button.H"


#include "FL/Fl_Round_Button.H"


#include "FL/Fl_Radio_Round_Button.H"


#include "FL/Fl_Repeat_Button.H"


#include "FL/Fl_Return_Button.H"


#include "FL/Fl_Roller.H"


#include "FL/Fl_Round_Clock.H"


#include "FL/Fl_Scroll.H"

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_Scrollbar.H"


#include "FL/Fl_Secret_Input.H"


#include "FL/Fl_Select_Browser.H"


#include "FL/Fl_Shared_Image.H"


#include "FL/Fl_Spinner.H"

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->mininum();
  }
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->maxinum();
  }

#include "FL/fl_show_colormap.H"


#include "FL/fl_show_input.H"


#include "FL/Fl_Simple_Counter.H"


#include "FL/Fl_Tabs.H"


#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 =  PyEval_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 =  PyEval_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_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"


#include "FL/Fl_Tile.H"


#include "FL/Fl_Tiled_Image.H"


#include "FL/Fl_Timer.H"


#include "FL/Fl_Toggle_Button.H"


#include "FL/Fl_Tooltip.H"


#include "FL/Fl_Value_Output.H"


#include "FL/Fl_Wizard.H"


#include "FL/Fl_XBM_Image.H"


#include "FL/Fl_XPM_Image.H"


#include "FL/x.H"


#include "FL/Fl_Tree_Prefs.H"


#include "FL/Fl_Tree_Item_Array.H"


#include "FL/Fl_Tree_Item.H"


#include "FL/Fl_Tree.H"


#include "FL/Fl_Paged_Device.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 <string>


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


#include "FL/Fl_Table.H"


#include "FL/Fl_Table_Row.H"


#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)
{
	int 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 *)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); 
}




SwigDirector_Fl_Image::~SwigDirector_Fl_Image() {
}

Fl_Image *SwigDirector_Fl_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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, Fl_Pixmap const *pxm, Fl_Color bg): Fl_RGB_Image(pxm, bg), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_RGB_Image *)this, this); 
}




SwigDirector_Fl_RGB_Image::~SwigDirector_Fl_RGB_Image() {
}

Fl_Image *SwigDirector_Fl_RGB_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Widget::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Widget::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Widget::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Widget::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Group::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Group::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Group::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Group::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Browser_::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Browser_::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Browser_::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Browser_::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void *SwigDirector_Fl_Browser_::item_first() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser_::item_next(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser_::item_prev(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser_::item_last() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser_::item_height(void *item) const {
  int c_result;
  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 = 12;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::item_width(void *item) const {
  int c_result;
  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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::item_quick_height(void *item) const {
  int c_result;
  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 = 14;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< 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 = 15;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


char const *SwigDirector_Fl_Browser_::item_text(void *item) const {
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  char *c_result;
  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 = 16;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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 = 17;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void *SwigDirector_Fl_Browser_::item_at(int index) const {
  void *argp ;
  int res ;
  
  void *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 18;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser_::full_width() const {
  int c_result;
  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 = 19;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::full_height() const {
  int c_result;
  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 = 20;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser_::incr_height() const {
  int c_result;
  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 = 21;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< 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 = 22;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Browser_::item_selected(void *item) const {
  int c_result;
  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 = 23;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Browser::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Browser::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Browser::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Browser::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void *SwigDirector_Fl_Browser::item_first() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser::item_next(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser::item_prev(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Browser::item_last() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser::item_height(void *item) const {
  int c_result;
  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 = 12;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::item_width(void *item) const {
  int c_result;
  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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::item_quick_height(void *item) const {
  int c_result;
  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 = 14;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< 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 = 15;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


char const *SwigDirector_Fl_Browser::item_text(void *item) const {
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  char *c_result;
  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 = 16;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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 = 17;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void *SwigDirector_Fl_Browser::item_at(int line) const {
  void *argp ;
  int res ;
  
  void *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 18;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Browser::full_width() const {
  int c_result;
  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 = 19;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::full_height() const {
  int c_result;
  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 = 20;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Browser::incr_height() const {
  int c_result;
  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 = 21;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< 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 = 22;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Browser::item_selected(void *item) const {
  int c_result;
  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 = 23;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_File_Browser::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_File_Browser::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_File_Browser::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_File_Browser::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void *SwigDirector_Fl_File_Browser::item_first() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_File_Browser::item_next(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_File_Browser::item_prev(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_File_Browser::item_last() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_File_Browser::item_height(void *item) const {
  int c_result;
  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 = 12;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::item_width(void *item) const {
  int c_result;
  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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::item_quick_height(void *item) const {
  int c_result;
  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 = 14;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< 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 = 15;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


char const *SwigDirector_Fl_File_Browser::item_text(void *item) const {
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  char *c_result;
  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 = 16;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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 = 17;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void *SwigDirector_Fl_File_Browser::item_at(int line) const {
  void *argp ;
  int res ;
  
  void *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 18;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_File_Browser::full_width() const {
  int c_result;
  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 = 19;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::full_height() const {
  int c_result;
  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 = 20;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_File_Browser::incr_height() const {
  int c_result;
  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 = 21;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< 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 = 22;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_File_Browser::item_selected(void *item) const {
  int c_result;
  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 = 23;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Adjuster::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Adjuster::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Adjuster::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Adjuster::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Adjuster::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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() {
}

Fl_Image *SwigDirector_Fl_Bitmap::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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() {
}

Fl_Image *SwigDirector_Fl_BMP_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Box::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Box::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Box::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Box::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Chart::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Chart::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Chart::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Chart::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Check_Browser::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Check_Browser::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Check_Browser::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Check_Browser::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void *SwigDirector_Fl_Check_Browser::item_first() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Check_Browser::item_next(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Check_Browser::item_prev(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Check_Browser::item_last() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Check_Browser::item_height(void *item) const {
  int c_result;
  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_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::item_width(void *item) const {
  int c_result;
  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_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::item_quick_height(void *item) const {
  int c_result;
  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 = 14;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Check_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(static_cast< int >(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(H));
  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 = 15;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


char const *SwigDirector_Fl_Check_Browser::item_text(void *item) const {
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  char *c_result;
  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 = 16;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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 );
  swig_set_inner("item_swap", 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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void *SwigDirector_Fl_Check_Browser::item_at(int index) const {
  void *argp ;
  int res ;
  
  void *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(index));
  swig_set_inner("item_at", 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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Check_Browser::full_width() const {
  int c_result;
  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 = 19;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::full_height() const {
  int c_result;
  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 = 20;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Check_Browser::incr_height() const {
  int c_result;
  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 = 21;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Check_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(static_cast< int >(val));
  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 = 22;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Check_Browser::item_selected(void *item) const {
  int c_result;
  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_Check_Browser.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Light_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Light_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Light_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Light_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Check_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Check_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Check_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Check_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Menu_::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Choice::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Choice::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Choice::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Choice::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Clock_Output::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Clock_Output::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Clock_Output::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Clock_Output::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Clock::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Clock::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Clock::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Clock::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Value_Input::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Value_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Value_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Value_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Value_Input::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Flcc_HueBox::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Flcc_HueBox::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Flcc_HueBox::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Flcc_HueBox::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Flcc_ValueBox::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Flcc_ValueBox::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Flcc_ValueBox::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Flcc_ValueBox::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Flcc_Value_Input::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Flcc_Value_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Flcc_Value_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Flcc_Value_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Flcc_Value_Input::format(char *arg0) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Color_Chooser::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Color_Chooser::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Color_Chooser::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Color_Chooser::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Counter::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Counter::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Counter::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Counter::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Counter::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Dial::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Dial::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Dial::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Dial::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Dial::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Window::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Window::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Window::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Window::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void SwigDirector_Fl_Window::flush() {
  swig_set_inner("flush", 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 = 7;
  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((char *)"flush");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("flush", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Double_Window::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Double_Window::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Double_Window::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Double_Window::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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 = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Input_::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Input_::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Input_::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Input_::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Input::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_File_Input::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_File_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_File_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_File_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Fill_Dial::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Fill_Dial::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Fill_Dial::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Fill_Dial::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Fill_Dial::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Fill_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Fill_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Fill_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Fill_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Fill_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Float_Input::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Float_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Float_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Float_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


SwigDirector_Fl_FormsBitmap::SwigDirector_Fl_FormsBitmap(PyObject *self, Fl_Boxtype arg0, int arg1, int arg2, int arg3, int arg4, char const *arg5): Fl_FormsBitmap(arg0, arg1, arg2, arg3, arg4, arg5), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_FormsBitmap *)this, this); 
}




SwigDirector_Fl_FormsBitmap::~SwigDirector_Fl_FormsBitmap() {
}

void SwigDirector_Fl_FormsBitmap::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_FormsBitmap::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_FormsBitmap::resize(int x, int y, int w, int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_FormsBitmap::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_FormsBitmap::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_FormsBitmap::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_FormsBitmap::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_FormsBitmap::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsBitmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


SwigDirector_Fl_FormsPixmap::SwigDirector_Fl_FormsPixmap(PyObject *self, Fl_Boxtype t, int X, int Y, int W, int H, char const *L): Fl_FormsPixmap(t, X, Y, W, H, L), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_FormsPixmap *)this, this); 
}




SwigDirector_Fl_FormsPixmap::~SwigDirector_Fl_FormsPixmap() {
}

void SwigDirector_Fl_FormsPixmap::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_FormsPixmap::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(event));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_FormsPixmap::resize(int x, int y, int w, int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_FormsPixmap::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_FormsPixmap::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_FormsPixmap::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_FormsPixmap::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_FormsPixmap::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_FormsPixmap.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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




SwigDirector_Fl_Free::~SwigDirector_Fl_Free() {
}

void SwigDirector_Fl_Free::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Free::handle(int e) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(e));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Free::resize(int x, int y, int w, int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Free::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Free::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Free::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Free::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Free::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Free.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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




SwigDirector_Fl_Pixmap::~SwigDirector_Fl_Pixmap() {
}

Fl_Image *SwigDirector_Fl_Pixmap::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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() {
}

Fl_Image *SwigDirector_Fl_GIF_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Gl_Window::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Gl_Window::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Gl_Window::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Gl_Window::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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 = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Help_View::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Help_View::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Help_View::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Help_View::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Hold_Browser::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hold_Browser::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Hold_Browser::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hold_Browser::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void *SwigDirector_Fl_Hold_Browser::item_first() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Hold_Browser::item_next(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Hold_Browser::item_prev(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Hold_Browser::item_last() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Hold_Browser::item_height(void *item) const {
  int c_result;
  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 = 12;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::item_width(void *item) const {
  int c_result;
  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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::item_quick_height(void *item) const {
  int c_result;
  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 = 14;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< 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 = 15;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


char const *SwigDirector_Fl_Hold_Browser::item_text(void *item) const {
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  char *c_result;
  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 = 16;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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 = 17;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void *SwigDirector_Fl_Hold_Browser::item_at(int line) const {
  void *argp ;
  int res ;
  
  void *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 18;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Hold_Browser::full_width() const {
  int c_result;
  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 = 19;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::full_height() const {
  int c_result;
  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 = 20;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Hold_Browser::incr_height() const {
  int c_result;
  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 = 21;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< 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 = 22;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Hold_Browser::item_selected(void *item) const {
  int c_result;
  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 = 23;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Fill_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Fill_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Fill_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Fill_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Hor_Fill_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Nice_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Nice_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Nice_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Nice_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Hor_Nice_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Hor_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Value_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Value_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Value_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Value_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Value_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Hor_Value_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Hor_Value_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Hor_Value_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Hor_Value_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Hor_Value_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Int_Input::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Int_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Int_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Int_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Input_Choice::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Input_Choice::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Input_Choice::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Input_Choice::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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): Fl_JPEG_Image(name, data), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_JPEG_Image *)this, this); 
}




SwigDirector_Fl_JPEG_Image::~SwigDirector_Fl_JPEG_Image() {
}

Fl_Image *SwigDirector_Fl_JPEG_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Line_Dial::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Line_Dial::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Line_Dial::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Line_Dial::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Line_Dial::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Menu_Bar::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_Bar::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_Bar::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_Bar::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Menu_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Single_Window::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Single_Window::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Single_Window::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Single_Window::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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 = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Menu_Window::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Menu_Window::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Menu_Window::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Menu_Window::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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 = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Multiline_Input::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Multiline_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Multiline_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Multiline_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Output::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Output::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Output::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Output::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Multiline_Output::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Multiline_Output::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Multiline_Output::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Multiline_Output::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Multi_Browser::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Multi_Browser::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Multi_Browser::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Multi_Browser::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void *SwigDirector_Fl_Multi_Browser::item_first() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Multi_Browser::item_next(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Multi_Browser::item_prev(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Multi_Browser::item_last() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Multi_Browser::item_height(void *item) const {
  int c_result;
  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 = 12;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::item_width(void *item) const {
  int c_result;
  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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::item_quick_height(void *item) const {
  int c_result;
  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 = 14;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< 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 = 15;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


char const *SwigDirector_Fl_Multi_Browser::item_text(void *item) const {
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  char *c_result;
  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 = 16;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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 = 17;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void *SwigDirector_Fl_Multi_Browser::item_at(int line) const {
  void *argp ;
  int res ;
  
  void *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 18;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Multi_Browser::full_width() const {
  int c_result;
  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 = 19;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::full_height() const {
  int c_result;
  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 = 20;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Multi_Browser::incr_height() const {
  int c_result;
  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 = 21;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< 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 = 22;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Multi_Browser::item_selected(void *item) const {
  int c_result;
  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 = 23;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Nice_Slider::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Nice_Slider::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Nice_Slider::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Nice_Slider::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Nice_Slider::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Overlay_Window::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Overlay_Window::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Overlay_Window::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Overlay_Window::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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 = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Overlay_Window::draw_overlay() {
  swig_set_inner("draw_overlay", 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 = 8;
  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((char *)"draw_overlay");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("draw_overlay", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Pack::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Pack::resize(int arg0, int arg1, int arg2, int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Pack::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Pack::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Pack::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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




SwigDirector_Fl_PNG_Image::~SwigDirector_Fl_PNG_Image() {
}

Fl_Image *SwigDirector_Fl_PNG_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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




SwigDirector_Fl_PNM_Image::~SwigDirector_Fl_PNM_Image() {
}

Fl_Image *SwigDirector_Fl_PNM_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Positioner::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Positioner::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Positioner::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Positioner::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Progress::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Progress::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Progress::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Progress::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Radio_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Radio_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Radio_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Radio_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Radio_Light_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Radio_Light_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Radio_Light_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Radio_Light_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Round_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Round_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Round_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Round_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Radio_Round_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Radio_Round_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Radio_Round_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Radio_Round_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Repeat_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Repeat_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Repeat_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Repeat_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Return_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Return_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Return_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Return_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Roller::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Roller::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Roller::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Roller::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Roller::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Round_Clock::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Round_Clock::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Round_Clock::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Round_Clock::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Scroll::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Scroll::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Scroll::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Scroll::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Scrollbar::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Scrollbar::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Scrollbar::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Scrollbar::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Scrollbar::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Secret_Input::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Secret_Input::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Secret_Input::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Secret_Input::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Select_Browser::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Select_Browser::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Select_Browser::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Select_Browser::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


void *SwigDirector_Fl_Select_Browser::item_first() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Select_Browser::item_next(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Select_Browser::item_prev(void *item) const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


void *SwigDirector_Fl_Select_Browser::item_last() const {
  void *argp ;
  int res ;
  
  void *c_result;
  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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Select_Browser::item_height(void *item) const {
  int c_result;
  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 = 12;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::item_width(void *item) const {
  int c_result;
  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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::item_quick_height(void *item) const {
  int c_result;
  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 = 14;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< 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 = 15;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


char const *SwigDirector_Fl_Select_Browser::item_text(void *item) const {
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  char *c_result;
  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 = 16;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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 = 17;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void *SwigDirector_Fl_Select_Browser::item_at(int line) const {
  void *argp ;
  int res ;
  
  void *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 18;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< void * >(argp);
  return (void *) c_result;
}


int SwigDirector_Fl_Select_Browser::full_width() const {
  int c_result;
  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 = 19;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::full_height() const {
  int c_result;
  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 = 20;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Select_Browser::incr_height() const {
  int c_result;
  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 = 21;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< 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 = 22;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Select_Browser::item_selected(void *item) const {
  int c_result;
  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 = 23;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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); 
}




SwigDirector_Fl_Shared_Image::~SwigDirector_Fl_Shared_Image() {
}

Fl_Image *SwigDirector_Fl_Shared_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Spinner::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Spinner::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Spinner::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Spinner::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Simple_Counter::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Simple_Counter::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Simple_Counter::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Simple_Counter::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Simple_Counter::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


SwigDirector_Fl_Tabs::SwigDirector_Fl_Tabs(PyObject *self, int arg0, int arg1, int arg2, int arg3, char const *arg4): Fl_Tabs(arg0, arg1, arg2, arg3, arg4), 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Tabs::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Tabs::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Tabs::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Tabs::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Text_Display::handle(int e) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Text_Display::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Text_Display::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Text_Display::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Text_Editor::handle(int e) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Text_Editor::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Text_Editor::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Text_Editor::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Tile::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Tile::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Tile::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Tile::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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




SwigDirector_Fl_Tiled_Image::~SwigDirector_Fl_Tiled_Image() {
}

Fl_Image *SwigDirector_Fl_Tiled_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


SwigDirector_Fl_Timer::SwigDirector_Fl_Timer(PyObject *self, uchar t, int x, int y, int w, int h, char const *l): Fl_Timer(t, x, y, w, h, l), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Timer *)this, this); 
}




SwigDirector_Fl_Timer::~SwigDirector_Fl_Timer() {
}

void SwigDirector_Fl_Timer::draw() {
  swig_set_inner("draw", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Timer::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Timer::resize(int x, int y, int w, int h) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(h));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Timer::show() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Timer::hide() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Timer::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Timer::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Timer::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Fl_Timer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Toggle_Button::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Toggle_Button::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Toggle_Button::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Toggle_Button::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Value_Output::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Value_Output::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Value_Output::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Value_Output::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


int SwigDirector_Fl_Value_Output::format(char *format_string) {
  int c_result;
  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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Wizard::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Wizard::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Wizard::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Wizard::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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




SwigDirector_Fl_XBM_Image::~SwigDirector_Fl_XBM_Image() {
}

Fl_Image *SwigDirector_Fl_XBM_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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




SwigDirector_Fl_XPM_Image::~SwigDirector_Fl_XPM_Image() {
}

Fl_Image *SwigDirector_Fl_XPM_Image::copy(int W, int H) {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Image *c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 0;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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(static_cast< unsigned int >(c));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 1;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(H));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(cx));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< 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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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() {
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Tree::handle(int e) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Tree::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Tree::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Tree::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


SwigDirector_Fl_Paged_Device::SwigDirector_Fl_Paged_Device(PyObject *self): Fl_Paged_Device(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Paged_Device *)this, this); 
}




SwigDirector_Fl_Paged_Device::~SwigDirector_Fl_Paged_Device() {
}

int SwigDirector_Fl_Paged_Device::start_job(int pagecount, int *frompage, int *topage) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 );
  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 = "start_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, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"start_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Paged_Device::start_page() {
  int c_result;
  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 = "start_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((char *)"start_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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Paged_Device::printable_rect(int *w, int *h) {
  int c_result;
  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 = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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 = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::origin(int x, int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::scale(float scale_x, float scale_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float(static_cast< float >(scale_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::rotate(float angle) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float(static_cast< 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 = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::translate(int x, int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::print_widget(Fl_Widget *widget, int delta_x, int delta_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(widget), SWIGTYPE_p_Fl_Widget,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(delta_x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(delta_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 = 10;
  const char * const swig_method_name = "print_widget";
  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((char *)"print_widget");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Paged_Device::print_window_part(Fl_Window *win, int x, int y, int w, int h, int delta_x, int delta_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(win), SWIGTYPE_p_Fl_Window,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(h));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< int >(delta_x));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_int(static_cast< int >(delta_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 = "print_window_part";
  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((char *)"print_window_part");
  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
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Paged_Device::end_page() {
  int c_result;
  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 = "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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


SwigDirector_Fl_Printer::SwigDirector_Fl_Printer(PyObject *self): Fl_Printer(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Fl_Printer *)this, this); 
}




SwigDirector_Fl_Printer::~SwigDirector_Fl_Printer() {
}

int SwigDirector_Fl_Printer::start_job(int pagecount, int *frompage, int *topage) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 );
  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 = "start_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, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"start_job");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Printer::start_page() {
  int c_result;
  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 = "start_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((char *)"start_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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_Fl_Printer::printable_rect(int *w, int *h) {
  int c_result;
  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_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_Fl_Printer::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_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Printer::origin(int x, int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 4;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Printer::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_Printer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Printer::scale(float scale_x, float scale_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float(static_cast< float >(scale_x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_float(static_cast< 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 = 6;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Printer::rotate(float angle) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_float(static_cast< 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 = 7;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Printer::translate(int x, int y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< 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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Printer::print_widget(Fl_Widget *widget, int delta_x, int delta_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(widget), SWIGTYPE_p_Fl_Widget,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(delta_x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(delta_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 = 10;
  const char * const swig_method_name = "print_widget";
  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((char *)"print_widget");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Printer::print_window_part(Fl_Window *win, int x, int y, int w, int h, int delta_x, int delta_y) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(win), SWIGTYPE_p_Fl_Window,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(h));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< int >(delta_x));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_int(static_cast< int >(delta_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 = "print_window_part";
  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((char *)"print_window_part");
  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
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Printer::end_page() {
  int c_result;
  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 = "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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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 = 13;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_ListSelect::handle(int arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(x));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(w));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_ListSelect::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_ListSelect::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_ListSelect::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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() {
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Table::handle(int e) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Table::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Table::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Table::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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(static_cast< int >(context));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(R));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(C));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(X));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_int(static_cast< 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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Table::rows(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Table::cols(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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() {
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


int SwigDirector_Fl_Table_Row::handle(int event) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = static_cast< 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(static_cast< int >(X));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< 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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


Fl_Group *SwigDirector_Fl_Table_Row::as_group() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Group *c_result;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Group * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Group *) c_result;
}


Fl_Window *SwigDirector_Fl_Table_Row::as_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Window *c_result;
  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_window";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject*) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< Fl_Window * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (Fl_Window *) c_result;
}


Fl_Gl_Window *SwigDirector_Fl_Table_Row::as_gl_window() {
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  Fl_Gl_Window *c_result;
  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_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((char *)"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) {
        PyErr_Print();
      }
    }
  }
  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 = reinterpret_cast< 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;
}


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(static_cast< int >(context));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(R));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(C));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(X));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(Y));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_int(static_cast< int >(W));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_int(static_cast< 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 = 8;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


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 = 9;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Table_Row::rows(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 10;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


void SwigDirector_Fl_Table_Row::cols(int val) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< 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 = 11;
  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((char *)"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) {
        PyErr_Print();
      }
    }
  }
}


#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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_ROUND_UP_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_ROUND_UP_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_SHADOW_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_SHADOW_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_SHADOW_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_ROUNDED_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_ROUNDED_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_ROUNDED_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_RFLAT_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_RFLAT_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_RFLAT_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_RSHADOW_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_RSHADOW_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_RSHADOW_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_DIAMOND_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_DIAMOND_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_DIAMOND_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_OVAL_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_OVAL_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_OVAL_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_PLASTIC_UP_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_PLASTIC_UP_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_PLASTIC_UP_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_GTK_UP_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_GTK_UP_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_GTK_UP_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_GLEAM_UP_BOX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_GLEAM_UP_BOX",0,0)) SWIG_fail;
  result = (Fl_Boxtype)fl_define_FL_GLEAM_UP_BOX();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_box(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_box",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_box" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (Fl_Boxtype)fl_box(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_down(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_down",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_down" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (Fl_Boxtype)fl_down(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_frame__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_frame",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_frame" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (Fl_Boxtype)fl_frame(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_SHADOW_LABEL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_SHADOW_LABEL",0,0)) SWIG_fail;
  result = (Fl_Labeltype)fl_define_FL_SHADOW_LABEL();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_ENGRAVED_LABEL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_ENGRAVED_LABEL",0,0)) SWIG_fail;
  result = (Fl_Labeltype)fl_define_FL_ENGRAVED_LABEL();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_define_FL_EMBOSSED_LABEL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Labeltype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_define_FL_EMBOSSED_LABEL",0,0)) SWIG_fail;
  result = (Fl_Labeltype)fl_define_FL_EMBOSSED_LABEL();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_inactive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_inactive",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_inactive" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  result = (Fl_Color)fl_inactive(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_contrast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  Fl_Color arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_contrast",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_contrast" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_contrast" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  result = (Fl_Color)fl_contrast(arg1,arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_average(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_color_average",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color_average" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (Fl_Color)fl_color_average(arg1,arg2,arg3);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_lighter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_lighter",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_lighter" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  result = (Fl_Color)fl_lighter(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_darker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_darker",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_darker" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  result = (Fl_Color)fl_darker(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rgb_color__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rgb_color",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rgb_color" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = static_cast< uchar >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rgb_color" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rgb_color" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = static_cast< uchar >(val3);
  result = (Fl_Color)fl_rgb_color(arg1,arg2,arg3);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rgb_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rgb_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rgb_color" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = static_cast< uchar >(val1);
  result = (Fl_Color)fl_rgb_color(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rgb_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_fl_rgb_color__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_fl_rgb_color__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_gray_ramp",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_gray_ramp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Fl_Color)fl_gray_ramp(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_cube(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_color_cube",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color_cube" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_color_cube" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_color_cube" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Fl_Color)fl_color_cube(arg1,arg2,arg3);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_w",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  result = (int)((Fl_Image const *)arg1)->w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_h",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  result = (int)((Fl_Image const *)arg1)->h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_d",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  result = (int)((Fl_Image const *)arg1)->d();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_ld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_ld",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  result = (int)((Fl_Image const *)arg1)->ld();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_count",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  result = (int)((Fl_Image const *)arg1)->count();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char **result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_data",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  result = (char **)((Fl_Image const *)arg1)->data();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_fail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_fail",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Image * >(argp1);
  result = (int)(arg1)->fail();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Image(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Image",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_copy",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Image *)(arg1)->Fl_Image::copy(arg2,arg3);
    } else {
      result = (Fl_Image *)(arg1)->copy(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_copy",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Image * >(argp1);
  result = (Fl_Image *)(arg1)->copy();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Image_copy__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Image_copy__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Image_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Image::copy(int,int)\n"
    "    Fl_Image::copy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Image_color_average(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_color_average",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Image::color_average(arg2,arg3);
    } else {
      (arg1)->color_average(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_inactive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_inactive",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  (arg1)->inactive();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_desaturate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_desaturate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Image::desaturate();
    } else {
      (arg1)->desaturate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_label__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Image::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Image::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Image_label__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_draw",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->draw(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_Image_draw__SWIG_1(self, args);
  }
  if ((argc >= 5) && (argc <= 7)) {
    return _wrap_Fl_Image_draw__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_uncache",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Image * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Image::uncache();
    } else {
      (arg1)->uncache();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_RGB_scaling__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Scaling arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_RGB_scaling",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< Fl_RGB_Scaling >(val1);
  Fl_Image::RGB_scaling(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_RGB_scaling__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Scaling result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Image_RGB_scaling",0,0)) SWIG_fail;
  result = (Fl_RGB_Scaling)Fl_Image::RGB_scaling();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Image_RGB_scaling(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Image_RGB_scaling__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Image_RGB_scaling__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Image *arg1 = (Fl_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_RGB_Image__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_RGB_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_RGB_Image",4,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  {
    /* Check if the input support the buffer protocol */
    Py_ssize_t size_buffer;
    const void * buffer;
    int failure = PyObject_AsReadBuffer(obj1,&buffer,&size_buffer);
    if (!failure) {
      // work with array object
      arg2 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_AsReadBuffer
      PyErr_Clear();
      size_buffer=0;
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(obj1)) {
        int size = PyList_Size(obj1);
        int i = 0;
        arg2 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_RGB_Image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_RGB_Image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_RGB_Image" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_RGB_Image" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_RGB_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_RGB_Image",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Pixmap * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_RGB_Image" "', argument " "3"" of type '" "Fl_Color""'");
    } 
    arg3 = static_cast< Fl_Color >(val3);
  }
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_new_Fl_RGB_Image__SWIG_1(self, args);
  }
  if ((argc >= 4) && (argc <= 6)) {
    return _wrap_new_Fl_RGB_Image__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(PyObject *,Fl_Pixmap const *,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_RGB_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_RGB_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_copy",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_RGB_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Image *)(arg1)->Fl_RGB_Image::copy(arg2,arg3);
    } else {
      result = (Fl_Image *)(arg1)->copy(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_copy",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  result = (Fl_Image *)(arg1)->copy();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_RGB_Image_copy__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_RGB_Image_copy__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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)\n"
    "    Fl_RGB_Image::copy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_color_average(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_color_average",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_RGB_Image::color_average(arg2,arg3);
    } else {
      (arg1)->color_average(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_desaturate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_desaturate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_RGB_Image::desaturate();
    } else {
      (arg1)->desaturate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_draw",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_RGB_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_RGB_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_RGB_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_RGB_Image_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_RGB_Image_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_RGB_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_RGB_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->draw(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_RGB_Image_draw__SWIG_1(self, args);
  }
  if ((argc >= 5) && (argc <= 7)) {
    return _wrap_Fl_RGB_Image_draw__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_RGB_Image::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_RGB_Image::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } 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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_RGB_Image_label__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_uncache",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_RGB_Image::uncache();
    } else {
      (arg1)->uncache();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_max_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_max_size",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &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 = static_cast< size_t >(val1);
  Fl_RGB_Image::max_size(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_max_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_RGB_Image_max_size",0,0)) SWIG_fail;
  result = Fl_RGB_Image::max_size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_RGB_Image_max_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_RGB_Image_max_size__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_RGB_Image_max_size__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_RGB_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_RGB_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_RGB_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Label_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Label_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Label * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Label_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Label_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Label_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Label_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Label_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = static_cast< Fl_Align >(val6);
  ((Fl_Label const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Label_measure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *arg1 = (Fl_Label *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Label_measure",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Label * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Label_measure" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Label_measure" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Label_measure" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Label_measure" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ((Fl_Label const *)arg1)->measure(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Label",0,0)) SWIG_fail;
  result = (Fl_Label *)new Fl_Label();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Label *arg1 = (Fl_Label *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Label * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Label_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Label, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Widget(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Widget",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Widget" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Widget" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Widget" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Widget" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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;
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Widget",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Widget::draw");
    } else {
      (arg1)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Widget::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_is_label_copied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_is_label_copied",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)((Fl_Widget const *)arg1)->is_label_copied();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_parent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Group *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_parent",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Group *)((Fl_Widget const *)arg1)->parent();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_parent",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Group * >(argp2);
  (arg1)->parent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_parent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_parent__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_parent__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_type",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (uchar)((Fl_Widget const *)arg1)->type();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_type__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_type",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_type" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->type(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_type(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_type__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_type__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_x",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)((Fl_Widget const *)arg1)->x();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_y",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)((Fl_Widget const *)arg1)->y();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_w",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)((Fl_Widget const *)arg1)->w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_h",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)((Fl_Widget const *)arg1)->h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Widget::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_damage_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_damage_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_damage_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_damage_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_damage_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (int)(arg1)->damage_resize(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_position(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_position",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->position(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_size(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_size",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->size(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_align__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Align result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_align",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Align)((Fl_Widget const *)arg1)->align();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_align__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Align arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_align",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_align" "', argument " "2"" of type '" "Fl_Align""'");
  } 
  arg2 = static_cast< Fl_Align >(val2);
  (arg1)->align(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_align(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_align__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_align__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Boxtype)((Fl_Widget const *)arg1)->box();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_box__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Boxtype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_box",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  (arg1)->box(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_box(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_box__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_box__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Color)((Fl_Widget const *)arg1)->color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_selection_color__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_selection_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Color)((Fl_Widget const *)arg1)->selection_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_selection_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_selection_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_selection_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->selection_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_selection_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_selection_color__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_selection_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_color",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_color" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = static_cast< Fl_Color >(val3);
  (arg1)->color(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_color__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_color__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Widget_color__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (char *)((Fl_Widget const *)arg1)->label();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_copy_label(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_copy_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->copy_label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_label",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_label" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = static_cast< Fl_Labeltype >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  (arg1)->label(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_label__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_label__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Widget_label__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Labeltype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labeltype",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Labeltype)((Fl_Widget const *)arg1)->labeltype();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labeltype__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Labeltype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labeltype",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labeltype" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = static_cast< Fl_Labeltype >(val2);
  (arg1)->labeltype(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labeltype(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_labeltype__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_labeltype__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labelcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Color)((Fl_Widget const *)arg1)->labelcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labelcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labelcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->labelcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_labelcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_labelcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labelfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Font)((Fl_Widget const *)arg1)->labelfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labelfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->labelfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_labelfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_labelfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labelsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Fontsize)((Fl_Widget const *)arg1)->labelsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_labelsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->labelsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_labelsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_labelsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_labelsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Image *)(arg1)->image();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Image *)((Fl_Widget const *)arg1)->image();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_image",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->image(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_image(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_image__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_image__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_image__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_deimage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_deimage",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Image *)(arg1)->deimage();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_deimage",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Image *)((Fl_Widget const *)arg1)->deimage();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_deimage",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->deimage(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deimage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_deimage__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_deimage__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_deimage__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_tooltip__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_tooltip",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (char *)((Fl_Widget const *)arg1)->tooltip();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_tooltip__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_tooltip",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->tooltip((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_tooltip(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_tooltip__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_tooltip__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_copy_tooltip",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->copy_tooltip((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Callback_p result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_callback",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Callback_p)((Fl_Widget const *)arg1)->callback();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_callback",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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(obj2,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 *""'"); 
  }
  (arg1)->callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_callback",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 *""'"); 
    }
  }
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Callback0 *arg2 = (Fl_Callback0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_callback",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 *""'"); 
    }
  }
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_callback",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 (obj2) {
    ecode3 = SWIG_AsVal_long(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_callback" "', argument " "3"" of type '" "long""'");
    } 
    arg3 = static_cast< long >(val3);
  }
  (arg1)->callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_user_data",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (void *)((Fl_Widget const *)arg1)->user_data();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_user_data",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_user_data" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->user_data(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_argument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_argument",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (long)((Fl_Widget const *)arg1)->argument();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_argument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_argument",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_argument" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->argument(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_argument(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_argument__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_argument__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_When result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_when",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_When)((Fl_Widget const *)arg1)->when();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_when__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_when",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_when" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->when(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_when(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_when__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_when__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (unsigned int)((Fl_Widget const *)arg1)->visible();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_r(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_visible_r",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)((Fl_Widget const *)arg1)->visible_r();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_show",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Widget::show();
    } else {
      (arg1)->show();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Widget::hide();
    } else {
      (arg1)->hide();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_visible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_set_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->set_visible();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_visible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_clear_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->clear_visible();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_active",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (unsigned int)((Fl_Widget const *)arg1)->active();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_active_r(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_active_r",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)((Fl_Widget const *)arg1)->active_r();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_activate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_activate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->activate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_deactivate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_deactivate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->deactivate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (unsigned int)((Fl_Widget const *)arg1)->output();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_set_output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->set_output();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_clear_output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->clear_output();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_takesevents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_takesevents",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (unsigned int)((Fl_Widget const *)arg1)->takesevents();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_changed",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (unsigned int)((Fl_Widget const *)arg1)->changed();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_set_changed",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->set_changed();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_clear_changed",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->clear_changed();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_clear_active",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->clear_active();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_set_active",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->set_active();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_take_focus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_take_focus",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)(arg1)->take_focus();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_set_visible_focus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_set_visible_focus",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->set_visible_focus();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_visible_focus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_clear_visible_focus",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->clear_visible_focus();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_focus__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_visible_focus",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_visible_focus" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->visible_focus(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_focus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_visible_focus",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (unsigned int)(arg1)->visible_focus();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_visible_focus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_visible_focus__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_visible_focus__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_default_callback(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_default_callback",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 *""'"); 
  }
  Fl_Widget::default_callback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_do_callback",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->do_callback();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_do_callback",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  ecode3 = SWIG_AsVal_long(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_do_callback" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->do_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_do_callback",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2,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 *""'"); 
    }
  }
  (arg1)->do_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_do_callback(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_do_callback__SWIG_0(self, args);
  }
  if ((argc >= 2) && (argc <= 3)) {
    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;
    }
    return _wrap_Fl_Widget_do_callback__SWIG_2(self, args);
  }
check_2:
  
  if (argc == 3) {
    return _wrap_Fl_Widget_do_callback__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Widget_do_callback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::do_callback()\n"
    "    Fl_Widget::do_callback(Fl_Widget *,long)\n"
    "    Fl_Widget::do_callback(Fl_Widget *,void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_test_shortcut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_test_shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)(arg1)->test_shortcut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_label_shortcut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_label_shortcut",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_Widget_label_shortcut" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (unsigned int)Fl_Widget::label_shortcut((char const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_test_shortcut__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_test_shortcut",1,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_Widget_test_shortcut" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_test_shortcut" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  result = (int)Fl_Widget::test_shortcut((char const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_test_shortcut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if ((argc >= 1) && (argc <= 2)) {
    return _wrap_Fl_Widget_test_shortcut__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget__set_fullscreen",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->_set_fullscreen();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget__clear_fullscreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget__clear_fullscreen",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->_clear_fullscreen();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_contains(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_contains",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (int)((Fl_Widget const *)arg1)->contains((Fl_Widget const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_inside(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_inside",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (int)((Fl_Widget const *)arg1)->inside((Fl_Widget const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_redraw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_redraw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->redraw();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_redraw_label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_redraw_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  (arg1)->redraw_label();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_damage",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (uchar)((Fl_Widget const *)arg1)->damage();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_clear_damage(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_clear_damage",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_clear_damage" "', argument " "2"" of type '" "uchar""'");
    } 
    arg2 = static_cast< uchar >(val2);
  }
  (arg1)->clear_damage(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_damage",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_damage" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->damage(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_damage",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_damage" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_damage" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_damage" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_damage" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Widget_damage" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->damage(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_damage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_damage__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_damage__SWIG_1(self, args);
  }
  if (argc == 6) {
    return _wrap_Fl_Widget_damage__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_draw_label",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_draw_label" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Widget_draw_label" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Widget_draw_label" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Widget_draw_label" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Widget_draw_label" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = static_cast< Fl_Align >(val6);
  ((Fl_Widget const *)arg1)->draw_label(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_measure_label(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_measure_label",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Widget_measure_label" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Widget_measure_label" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Widget_measure_label" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Widget_measure_label" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ((Fl_Widget const *)arg1)->measure_label(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Window *)((Fl_Widget const *)arg1)->window();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_top_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Window *)((Fl_Widget const *)arg1)->top_window();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_top_window_offset",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Widget_top_window_offset" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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_ValueError, "invalid null reference " "in method '" "Fl_Widget_top_window_offset" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (Fl_Window *)((Fl_Widget const *)arg1)->top_window_offset(*arg2,*arg3);
  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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Group *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_as_group",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Group *)(arg1)->Fl_Widget::as_group();
    } else {
      result = (Fl_Group *)(arg1)->as_group();
    }
  } 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_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_as_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Window *)(arg1)->Fl_Widget::as_window();
    } else {
      result = (Fl_Window *)(arg1)->as_window();
    }
  } 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_gl_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Gl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_as_gl_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    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_use_accents_menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_use_accents_menu",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)(arg1)->use_accents_menu();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_color2",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_color2" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Color)((Fl_Widget const *)arg1)->color2();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_color2",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_color2" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Widget_color2" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->color2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_color2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_color2__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Widget_color2__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Widget_color2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::color2() const\n"
    "    Fl_Widget::color2(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw_label__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_draw_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl_Widget_draw_label__SWIG_3(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_draw_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_draw_label__SWIG_3(self, args);
  }
  if (argc == 6) {
    return _wrap_Fl_Widget_draw_label__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_draw_backdrop",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl_Widget_draw_backdrop(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_callback",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  arg2 = obj1;
  arg3 = obj2;
  if (obj3) {
    arg4 = obj3;
  }
  Fl_Widget_callback__SWIG_5(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_callback(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_callback__SWIG_0(self, args);
  }
  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_2(self, args);
  }
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_3(self, args);
  }
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_4(self, args);
  }
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, args);
  }
check_5:
  
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_Fl_Widget_callback__SWIG_5(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *)\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_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_user_data",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  arg2 = obj1;
  Fl_Widget_user_data__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_user_data",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (PyObject *)Fl_Widget_user_data__SWIG_3(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_user_data(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_user_data__SWIG_3(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Widget_user_data__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_Fl_Widget_user_data__SWIG_1(self, args);
  }
check_3:
  
  if (argc == 2) {
    return _wrap_Fl_Widget_user_data__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Widget_user_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Widget::user_data() const\n"
    "    Fl_Widget::user_data(void *)\n"
    "    Fl_Widget::user_data(PyObject *)\n"
    "    Fl_Widget::user_data()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Widget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Widget",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Widget, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Group_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Group *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Group *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Group::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_begin",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  (arg1)->begin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_end",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  (arg1)->end();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_current__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Group *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_current",0,0)) SWIG_fail;
  result = (Fl_Group *)Fl_Group::current();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_current",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  Fl_Group::current(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_current(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Group_current__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Group_current__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_children",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  result = (int)((Fl_Group const *)arg1)->children();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_child(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Fl_Widget *)((Fl_Group const *)arg1)->child(arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_find(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_find",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Group_find" "', argument " "2"" of type '" "Fl_Widget const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (int)((Fl_Group const *)arg1)->find((Fl_Widget const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Group_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Group_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Group_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Group::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Group(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Group *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Group",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Group" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Group" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Group" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Group" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Group",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_add(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_insert",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Group_insert" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Group_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_insert_before(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_insert_before",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Group_insert_before" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Widget * >(argp3);
  (arg1)->insert(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_remove(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Group_remove__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_resizable__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_resizable",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->resizable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_resizable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_resizable",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  result = (Fl_Widget *)((Fl_Group const *)arg1)->resizable();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Group_resizable__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Group_resizable__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_add_resizable",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Group_add_resizable" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->add_resizable(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_init_sizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_init_sizes",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  (arg1)->init_sizes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_clip_children__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_clip_children",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Group_clip_children" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->clip_children(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_clip_children__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_clip_children",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  result = (unsigned int)(arg1)->clip_children();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_clip_children(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Group_clip_children__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Group_clip_children__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Group *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_as_group",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Group *)(arg1)->Fl_Group::as_group();
    } else {
      result = (Fl_Group *)(arg1)->as_group();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_focus(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_focus",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_focus" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Group_focus" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->focus(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group__ddfdesign_kludge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Widget **result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group__ddfdesign_kludge",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Group * >(argp1);
  result = (Fl_Widget **) &(arg1)->_ddfdesign_kludge();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Fl_Widget, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Group_forms_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Group_forms_end",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Group_forms_end" "', argument " "1"" of type '" "Fl_Group *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Group * >(argp1);
  (arg1)->forms_end();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Group *arg1 = (Fl_Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Group",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Group, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_End(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_End *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_End",0,0)) SWIG_fail;
  result = (Fl_End *)new Fl_End();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_End *arg1 = (Fl_End *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_End",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_End * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_End_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_End, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Browser__item_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_first");
    } else {
      result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_first();
    }
  } 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_next");
    } else {
      result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_next(arg2);
    }
  } 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_prev",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_prev");
    } else {
      result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_prev(arg2);
    }
  } 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_lastSwigPublic();
    } else {
      result = (void *)((SwigDirector_Fl_Browser_ const *)darg)->item_last();
    }
  } 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_height");
    } else {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_height(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_width(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Browser_::item_width");
    } else {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->item_width(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_quick_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_quick_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser__item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Browser__item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Browser__item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      (darg)->item_swapSwigPublic(arg2,arg3);
    } else {
      (darg)->item_swap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_at",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__full_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_widthSwigPublic();
    } else {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_width();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__full_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__full_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_heightSwigPublic();
    } else {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->full_height();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__incr_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__incr_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->incr_heightSwigPublic();
    } else {
      result = (int)((SwigDirector_Fl_Browser_ const *)darg)->incr_height();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_select",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__item_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      (darg)->item_selectSwigPublic(arg2,arg3);
    } else {
      (darg)->item_select(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__item_selected(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__item_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser_ *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser_ *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Browser_(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Browser_ *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Browser_",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Browser_" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Browser_" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Browser_" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Browser_" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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;
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Browser_::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser__resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Browser__resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Browser_::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__select",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser__select" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  result = (int)(arg1)->select(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__select_only(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__select_only",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser__select_only" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->select_only(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__deselect(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__deselect",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__deselect" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (int)(arg1)->deselect(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__position__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__position",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__position" "', argument " "1"" of type '" "Fl_Browser_ const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (int)((Fl_Browser_ const *)arg1)->position();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__position__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__position",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Browser_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Browser__position" "', argument " "1"" of type '" "Fl_Browser_ *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->position(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__position(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__position__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__position__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Browser__position'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Browser_::position() const\n"
    "    Fl_Browser_::position(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__hposition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__hposition",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (int)((Fl_Browser_ const *)arg1)->hposition();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__hposition__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__hposition",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__hposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->hposition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__hposition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__hposition__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__hposition__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__display",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 *""'"); 
  }
  (arg1)->display(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__has_scrollbar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__has_scrollbar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (uchar)((Fl_Browser_ const *)arg1)->has_scrollbar();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__has_scrollbar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__has_scrollbar",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__has_scrollbar" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->has_scrollbar(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__has_scrollbar(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__has_scrollbar__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__has_scrollbar__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (Fl_Font)((Fl_Browser_ const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (Fl_Fontsize)((Fl_Browser_ const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (Fl_Color)((Fl_Browser_ const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__scrollbar_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (int)((Fl_Browser_ const *)arg1)->scrollbar_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_size__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__scrollbar_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->scrollbar_size(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__scrollbar_size__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__scrollbar_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__scrollbar_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (int)((Fl_Browser_ const *)arg1)->scrollbar_width();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_width__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__scrollbar_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__scrollbar_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->scrollbar_width(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_width(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser__scrollbar_width__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser__scrollbar_width__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__scrollbar_right",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  (arg1)->scrollbar_right();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__scrollbar_left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__scrollbar_left",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  (arg1)->scrollbar_left();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__sort(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__sort",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser__sort" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  (arg1)->sort(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser__getScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Scrollbar *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__getScrollbar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (Fl_Scrollbar *)Fl_Browser__getScrollbar(arg1);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Scrollbar *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser__getHScrollbar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  result = (Fl_Scrollbar *)Fl_Browser__getHScrollbar(arg1);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Browser_",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser_ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Browser_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser_ *arg1 = (Fl_Browser_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Browser_",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Browser_, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Browser_item_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_firstSwigPublic();
    } else {
      result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_first();
    }
  } 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_prev",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_lastSwigPublic();
    } else {
      result = (void *)((SwigDirector_Fl_Browser const *)darg)->item_last();
    }
  } 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_select",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      (darg)->item_selectSwigPublic(arg2,arg3);
    } else {
      (darg)->item_select(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_width(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_full_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_full_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      result = (int)((SwigDirector_Fl_Browser const *)darg)->full_heightSwigPublic();
    } else {
      result = (int)((SwigDirector_Fl_Browser const *)darg)->full_height();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_incr_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_incr_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      result = (int)((SwigDirector_Fl_Browser const *)darg)->incr_heightSwigPublic();
    } else {
      result = (int)((SwigDirector_Fl_Browser const *)darg)->incr_height();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      (darg)->item_swapSwigPublic(arg2,arg3);
    } else {
      (darg)->item_swap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_at",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_move",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_move" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->move(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_load(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_load",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->load((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_swap(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_swap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_swap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->swap(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  result = (int)((Fl_Browser const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_size__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_size",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->size(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_size__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Browser_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  result = (Fl_Fontsize)((Fl_Browser const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_topline",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  result = (int)((Fl_Browser const *)arg1)->topline();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_lineposition(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_lineposition",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_lineposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &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 = static_cast< Fl_Browser::Fl_Line_Position >(val3);
  (arg1)->lineposition(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_topline__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_topline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_topline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->topline(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_topline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_topline__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_topline__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_bottomline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_bottomline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->bottomline(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_middleline(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_middleline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_middleline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->middleline(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_select",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_select" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->select(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_selected(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_selected" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Browser const *)arg1)->selected(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_show__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_show",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_show" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->show(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_show__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_show",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Browser::show();
    } else {
      (arg1)->show();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_show(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_show__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_show__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_hide",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_hide" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->hide(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_hide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Browser::hide();
    } else {
      (arg1)->hide();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_hide(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_hide__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_hide__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_visible",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_visible" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Browser const *)arg1)->visible(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  result = (int)((Fl_Browser const *)arg1)->value();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_value__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)((Fl_Browser const *)arg1)->text(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_text__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_text",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  (arg1)->text(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_text(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_text__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Browser_text__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Browser",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_format_char__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_format_char",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  result = (char)((Fl_Browser const *)arg1)->format_char();
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_format_char__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_format_char",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_format_char" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->format_char(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_format_char(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_format_char__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_format_char__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_column_char",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  result = (char)((Fl_Browser const *)arg1)->column_char();
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_char__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_column_char",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_column_char" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->column_char(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_char(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_column_char__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_column_char__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_column_widths",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  result = (int *)((Fl_Browser const *)arg1)->column_widths();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_displayed(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_displayed",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_displayed" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Browser const *)arg1)->displayed(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_make_visible(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_make_visible",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_make_visible" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->make_visible(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_icon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_icon",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Image * >(argp3);
  (arg1)->icon(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_icon__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_icon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Fl_Image *)((Fl_Browser const *)arg1)->icon(arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_icon__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Browser_icon__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_remove_icon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_remove_icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove_icon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_replace(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_replace",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  (arg1)->replace(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_display(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_display",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_display" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Browser_display" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  (arg1)->display(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_add(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_add",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Browser_add(arg1,(char const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_insert",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  if (obj3) {
    arg4 = obj3;
  }
  Fl_Browser_insert(arg1,arg2,(char const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_get_data(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_get_data",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_get_data" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (PyObject *)Fl_Browser_get_data(arg1,arg2);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_data(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_data",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Browser_data" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    arg3 = obj2;
  }
  result = (PyObject *)Fl_Browser_data(arg1,arg2,arg3);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_widths__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_column_widths",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  arg2 = obj1;
  Fl_Browser_column_widths__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_column_widths(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Browser_column_widths__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Browser_column_widths__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_item_quick_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_item_quick_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Browser_full_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Browser *arg1 = (Fl_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Browser_full_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Browser *>(arg1);
    if (upcall) {
      result = (int)((SwigDirector_Fl_Browser const *)darg)->full_widthSwigPublic();
    } else {
      result = (int)((SwigDirector_Fl_Browser const *)darg)->full_width();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Browser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Browser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_File_Browser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_File_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_File_Browser",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_File_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_File_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_File_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_Fl_File_Browser_iconsize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_iconsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  result = (uchar)((Fl_File_Browser const *)arg1)->iconsize();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_iconsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_iconsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_iconsize" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->iconsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_iconsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Browser_iconsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Browser_iconsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_filter",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->filter((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_filter",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  result = (char *)((Fl_File_Browser const *)arg1)->filter();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filter(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Browser_filter__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Browser_filter__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  result = (Fl_Fontsize)((Fl_File_Browser const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Browser_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Browser_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_filetype",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  result = (int)((Fl_File_Browser const *)arg1)->filetype();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filetype__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_filetype",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_filetype" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->filetype(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_filetype(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Browser_filetype__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Browser_filetype__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_load(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_load",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  arg2 = obj1;
  arg3 = obj2;
  result = (int)Fl_File_Browser_load_new(arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_File_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_File_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_File_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_File_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_prev",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_width(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_quick_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_quick_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_File_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_File_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_File_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    if (upcall) {
      (darg)->item_swapSwigPublic(arg2,arg3);
    } else {
      (darg)->item_swap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_at",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_full_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_full_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_full_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_incr_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Browser *arg1 = (Fl_File_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_incr_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_select",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    if (upcall) {
      (darg)->item_selectSwigPublic(arg2,arg3);
    } else {
      (darg)->item_select(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Browser_item_selected(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Browser_item_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_File_Browser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_File_Browser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_File_Icon(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_File_Icon *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_File_Icon",2,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 '" "new_Fl_File_Icon" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_File_Icon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Icon" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &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 = reinterpret_cast< short * >(argp4);
  }
  result = (Fl_File_Icon *)new Fl_File_Icon((char const *)arg1,arg2,arg3,arg4);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_File_Icon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_add(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  short *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  ecode2 = SWIG_AsVal_short(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_add" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  result = (short *)(arg1)->add(arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  short *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_add_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  result = (short *)(arg1)->add_color(arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  short *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_add_vertex",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_add_vertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_add_vertex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (short *)(arg1)->add_vertex(arg2,arg3);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  short *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_add_vertex",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_add_vertex" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_add_vertex" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  result = (short *)(arg1)->add_vertex(arg2,arg3);
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_File_Icon_add_vertex__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_draw",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_File_Icon_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_File_Icon_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_File_Icon_draw" "', argument " "6"" of type '" "Fl_Color""'");
  } 
  arg6 = static_cast< Fl_Color >(val6);
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_File_Icon_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  (arg1)->draw(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_label(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->label(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_labeltype(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_labeltype",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Label * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_labeltype" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Icon_labeltype" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_File_Icon_labeltype" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_File_Icon_labeltype" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_File_Icon_labeltype" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = static_cast< Fl_Align >(val6);
  Fl_File_Icon::labeltype((Fl_Label const *)arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_load(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_load",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->load((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_load_fti(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_load_fti",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->load_fti((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_load_image(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_load_image",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->load_image((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_File_Icon *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_next",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  result = (Fl_File_Icon *)(arg1)->next();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_pattern",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  result = (char *)(arg1)->pattern();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  result = (int)(arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_type",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  result = (int)(arg1)->type();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Icon_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *arg1 = (Fl_File_Icon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  short *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Icon * >(argp1);
  result = (short *)(arg1)->value();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_File_Icon *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_find",1,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_File_Icon_find" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Icon_find" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (Fl_File_Icon *)Fl_File_Icon::find((char const *)arg1,arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Icon *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_first",0,0)) SWIG_fail;
  result = (Fl_File_Icon *)Fl_File_Icon::first();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Icon_load_system_icons",0,0)) SWIG_fail;
  Fl_File_Icon::load_system_icons();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_File_Icon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_File_Icon, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_File_Chooser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_File_Chooser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_File_Chooser",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 '" "new_Fl_File_Chooser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_File_Chooser" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Chooser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  result = (Fl_File_Chooser *)new Fl_File_Chooser((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_File_Chooser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_callback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_callback",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 (obj2) {
    res3 = SWIG_ConvertPtr(obj2,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 *""'"); 
    }
  }
  (arg1)->callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_color__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (Fl_Color)(arg1)->color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_color__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_color__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_count",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (int)(arg1)->count();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_directory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_directory",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->directory((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_directory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_directory",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (char *)(arg1)->directory();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_directory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_directory__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_directory__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_filter",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->filter((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_filter",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (char *)(arg1)->filter();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_filter__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_filter__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_filter_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (int)(arg1)->filter_value();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_filter_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_filter_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->filter_value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_filter_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_filter_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_filter_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  (arg1)->hide();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_iconsize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_iconsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_iconsize" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->iconsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_iconsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_iconsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (uchar)(arg1)->iconsize();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_iconsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_iconsize__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_iconsize__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (char *)(arg1)->label();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_label__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_label__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_ok_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->ok_label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_ok_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_ok_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (char *)(arg1)->ok_label();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_ok_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_ok_label__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_ok_label__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_preview",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_preview" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->preview(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_preview__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_preview",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (int)((Fl_File_Chooser const *)arg1)->preview();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_preview(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_preview__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_preview__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_rescan",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  (arg1)->rescan();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_show",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  (arg1)->show();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_shown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_shown",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (int)(arg1)->shown();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textcolor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (Fl_Color)(arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_textcolor__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_textcolor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (Fl_Font)(arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_textfont__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_textfont__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (Fl_Fontsize)(arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_textsize__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_textsize__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_type",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_type" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->type(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_type__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_type",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (int)(arg1)->type();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_type(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_type__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_type__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_user_data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_user_data",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (void *)((Fl_File_Chooser const *)arg1)->user_data();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_user_data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_user_data",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_File_Chooser_user_data" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->user_data(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_user_data(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Chooser_user_data__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_user_data__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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() const\n"
    "    Fl_File_Chooser::user_data(void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_value",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Chooser_value" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (char *)(arg1)->value(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->value((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_File_Chooser_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Chooser *arg1 = (Fl_File_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  result = (int)(arg1)->visible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_add_extra(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_add_extra",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (Fl_Widget *)(arg1)->add_extra(arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Chooser_callback",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Chooser * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  arg3 = obj2;
  if (obj3) {
    arg4 = obj3;
  }
  Fl_File_Chooser_callback__SWIG_1(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Chooser_callback(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_Fl_File_Chooser_callback__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *Fl_File_Chooser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_File_Chooser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fl_dir_chooser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_dir_chooser",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_dir_chooser" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (char *)fl_dir_chooser((char const *)arg1,(char const *)arg2,arg3);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_file_chooser",3,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_file_chooser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_file_chooser" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_file_chooser" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  result = (char *)fl_file_chooser((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  void (*arg1)(char const *) = (void (*)(char const *)) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_file_chooser_callback",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (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 *)""'"); 
    }
  }
  fl_file_chooser_callback(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_file_chooser_ok_label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_file_chooser_ok_label",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_file_chooser_ok_label" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_file_chooser_ok_label((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}



#ifdef __APPLE__ 
  // empty implementation
  Fl::free_color(Fl_Color i, int overlay) 
    {
    }
#endif 
  
SWIGINTERN PyObject *_wrap_Fl_call_screen_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_call_screen_init",0,0)) SWIG_fail;
  Fl::call_screen_init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_damage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_damage",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_damage" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  Fl::damage(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_option__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl::Fl_Option arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_option",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_option" "', argument " "1"" of type '" "Fl::Fl_Option""'");
  } 
  arg1 = static_cast< Fl::Fl_Option >(val1);
  result = (bool)Fl::option(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_option__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl::Fl_Option arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_option",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_option" "', argument " "1"" of type '" "Fl::Fl_Option""'");
  } 
  arg1 = static_cast< Fl::Fl_Option >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_option" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  Fl::option(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_option(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_option__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_option__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_option'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::option(Fl::Fl_Option)\n"
    "    Fl::option(Fl::Fl_Option,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_add_awake_handler_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Awake_Handler arg1 = (Fl_Awake_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_add_awake_handler_",2,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_add_awake_handler_" "', argument " "1"" of type '" "Fl_Awake_Handler""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_add_awake_handler_" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (int)Fl::add_awake_handler_(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_version",0,0)) SWIG_fail;
  result = (double)Fl::version();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_api_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_api_version",0,0)) SWIG_fail;
  result = (int)Fl::api_version();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_abi_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_abi_version",0,0)) SWIG_fail;
  result = (int)Fl::abi_version();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_abi_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) (int)(1*10000+3*100) ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_abi_check",0,1,&obj0)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_int(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_abi_check" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  result = (int)Fl::abi_check(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_arg(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_arg",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_arg" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_arg" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_arg" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_arg" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (int)Fl::arg(arg1,arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_args__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_args",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_args" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_args" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_args" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_args" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  if (obj3) {
    {
      int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_int_p_p_char_r_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_args" "', argument " "4"" of type '" "Fl_Args_Handler""'"); 
      }
    }
  }
  result = (int)Fl::args(arg1,arg2,*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_args__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  char **arg2 = (char **) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_args",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_args" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_args" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);
  Fl::args(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_args(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_args__SWIG_1(self, args);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_Fl_args__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_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_Fl_display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_display",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_display" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  Fl::display((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_visual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_visual",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_visual" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)Fl::visual(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_own_colormap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_own_colormap",0,0)) SWIG_fail;
  Fl::own_colormap();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_get_system_colors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_get_system_colors",0,0)) SWIG_fail;
  Fl::get_system_colors();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_foreground(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_foreground",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_foreground" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = static_cast< uchar >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_foreground" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_foreground" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = static_cast< uchar >(val3);
  Fl::foreground(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_background(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_background",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_background" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = static_cast< uchar >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_background" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_background" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = static_cast< uchar >(val3);
  Fl::background(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_background2(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_background2",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_background2" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = static_cast< uchar >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_background2" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_background2" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = static_cast< uchar >(val3);
  Fl::background2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_scheme__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_scheme",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_scheme" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)Fl::scheme((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_scheme__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_scheme",0,0)) SWIG_fail;
  result = (char *)Fl::scheme();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_scheme(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_scheme__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_scheme__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_scheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::scheme(char const *)\n"
    "    Fl::scheme()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_is_scheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_is_scheme",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_is_scheme" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)Fl::is_scheme((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_reload_scheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_reload_scheme",0,0)) SWIG_fail;
  result = (int)Fl::reload_scheme();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_scrollbar_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_scrollbar_size",0,0)) SWIG_fail;
  result = (int)Fl::scrollbar_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_scrollbar_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_scrollbar_size",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_scrollbar_size" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  Fl::scrollbar_size(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_scrollbar_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_scrollbar_size__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_scrollbar_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_scrollbar_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::scrollbar_size()\n"
    "    Fl::scrollbar_size(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_wait__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_wait",0,0)) SWIG_fail;
  result = (int)Fl::wait();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_wait__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_wait",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_wait" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (double)Fl::wait(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_wait(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_wait__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_wait__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_wait'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::wait()\n"
    "    Fl::wait(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_check",0,0)) SWIG_fail;
  result = (int)Fl::check();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_ready(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_ready",0,0)) SWIG_fail;
  result = (int)Fl::ready();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_run",0,0)) SWIG_fail;
  result = (int)Fl::run();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_readqueue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_readqueue",0,0)) SWIG_fail;
  result = (Fl_Widget *)Fl::readqueue();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_has_timeout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timeout_Handler arg1 = (Fl_Timeout_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_has_timeout",1,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_has_timeout" "', argument " "1"" of type '" "Fl_Timeout_Handler""'"); 
    }
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_has_timeout" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  result = (int)Fl::has_timeout(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_add_idle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Idle_Handler arg1 = (Fl_Idle_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_add_idle",1,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_add_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'"); 
    }
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_add_idle" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  Fl::add_idle(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_has_idle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Idle_Handler arg1 = (Fl_Idle_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_has_idle",1,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_has_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'"); 
    }
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_has_idle" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  result = (int)Fl::has_idle(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_remove_idle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Idle_Handler arg1 = (Fl_Idle_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_remove_idle",1,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_remove_idle" "', argument " "1"" of type '" "Fl_Idle_Handler""'"); 
    }
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_remove_idle" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  Fl::remove_idle(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_damage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_damage",0,0)) SWIG_fail;
  result = (int)Fl::damage();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_damage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_damage__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_damage__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_damage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::damage(int)\n"
    "    Fl::damage()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_redraw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_redraw",0,0)) SWIG_fail;
  Fl::redraw();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_flush",0,0)) SWIG_fail;
  Fl::flush();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_first_window__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_first_window",0,0)) SWIG_fail;
  result = (Fl_Window *)Fl::first_window();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_first_window__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_first_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_first_window" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Window * >(argp1);
  Fl::first_window(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_first_window(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_first_window__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_first_window__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_first_window'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::first_window()\n"
    "    Fl::first_window(Fl_Window *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_next_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_next_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_next_window" "', argument " "1"" of type '" "Fl_Window const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Window * >(argp1);
  result = (Fl_Window *)Fl::next_window((Fl_Window const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_modal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_modal",0,0)) SWIG_fail;
  result = (Fl_Window *)Fl::modal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_grab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_grab",0,0)) SWIG_fail;
  result = (Fl_Window *)Fl::grab();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Window, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_grab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_grab",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_grab" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Window * >(argp1);
  Fl::grab(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_grab(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_grab__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_grab__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_grab'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::grab()\n"
    "    Fl::grab(Fl_Window *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event",0,0)) SWIG_fail;
  result = (int)Fl::event();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_x",0,0)) SWIG_fail;
  result = (int)Fl::event_x();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_y",0,0)) SWIG_fail;
  result = (int)Fl::event_y();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_x_root(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_x_root",0,0)) SWIG_fail;
  result = (int)Fl::event_x_root();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_y_root(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_y_root",0,0)) SWIG_fail;
  result = (int)Fl::event_y_root();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_dx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_dx",0,0)) SWIG_fail;
  result = (int)Fl::event_dx();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_dy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_dy",0,0)) SWIG_fail;
  result = (int)Fl::event_dy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_get_mouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_get_mouse",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_get_mouse" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_get_mouse" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_get_mouse" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_get_mouse" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  Fl::get_mouse(*arg1,*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_clicks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_clicks",0,0)) SWIG_fail;
  result = (int)Fl::event_clicks();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_clicks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_clicks",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_event_clicks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  Fl::event_clicks(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_clicks(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_event_clicks__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_event_clicks__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_event_clicks'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::event_clicks()\n"
    "    Fl::event_clicks(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_event_is_click__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_is_click",0,0)) SWIG_fail;
  result = (int)Fl::event_is_click();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_is_click__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_is_click",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_event_is_click" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  Fl::event_is_click(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_is_click(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_event_is_click__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_event_is_click__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_event_is_click'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::event_is_click()\n"
    "    Fl::event_is_click(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_event_button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_button",0,0)) SWIG_fail;
  result = (int)Fl::event_button();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_state__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_state",0,0)) SWIG_fail;
  result = (int)Fl::event_state();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_state__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_state",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_event_state" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)Fl::event_state(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_state(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_event_state__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_event_state__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_event_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::event_state()\n"
    "    Fl::event_state(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_event_key__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_key",0,0)) SWIG_fail;
  result = (int)Fl::event_key();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_original_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_original_key",0,0)) SWIG_fail;
  result = (int)Fl::event_original_key();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_key__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_key",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_event_key" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)Fl::event_key(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_key(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_event_key__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_event_key__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_event_key'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::event_key()\n"
    "    Fl::event_key(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_get_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_get_key",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_get_key" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)Fl::get_key(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_text",0,0)) SWIG_fail;
  result = (char *)Fl::event_text();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_length",0,0)) SWIG_fail;
  result = (int)Fl::event_length();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_clipboard",0,0)) SWIG_fail;
  result = (void *)Fl::event_clipboard();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_clipboard_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_clipboard_type",0,0)) SWIG_fail;
  result = (char *)Fl::event_clipboard_type();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_compose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_compose",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_compose" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_compose" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  result = (int)Fl::compose(*arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_compose_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_compose_reset",0,0)) SWIG_fail;
  Fl::compose_reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_inside__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_inside",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_event_inside" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_event_inside" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_event_inside" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_event_inside" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)Fl::event_inside(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_inside__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_inside",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_event_inside" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (int)Fl::event_inside((Fl_Widget const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_inside(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_event_inside__SWIG_1(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_event_inside__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_event_inside'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::event_inside(int,int,int,int)\n"
    "    Fl::event_inside(Fl_Widget const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_test_shortcut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shortcut arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_test_shortcut",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_test_shortcut" "', argument " "1"" of type '" "Fl_Shortcut""'");
  } 
  arg1 = static_cast< Fl_Shortcut >(val1);
  result = (int)Fl::test_shortcut(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_enable_im(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_enable_im",0,0)) SWIG_fail;
  Fl::enable_im();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_disable_im(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_disable_im",0,0)) SWIG_fail;
  Fl::disable_im();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Window *arg2 = (Fl_Window *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_handle",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_handle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_handle" "', argument " "2"" of type '" "Fl_Window *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Window * >(argp2);
  result = (int)Fl::handle(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_handle_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Fl_Window *arg2 = (Fl_Window *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_handle_",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_handle_" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_handle_" "', argument " "2"" of type '" "Fl_Window *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Window * >(argp2);
  result = (int)Fl::handle_(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_belowmouse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_belowmouse",0,0)) SWIG_fail;
  result = (Fl_Widget *)Fl::belowmouse();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_belowmouse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_belowmouse",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_belowmouse" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl::belowmouse(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_belowmouse(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_belowmouse__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_belowmouse__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_belowmouse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::belowmouse()\n"
    "    Fl::belowmouse(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_pushed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_pushed",0,0)) SWIG_fail;
  result = (Fl_Widget *)Fl::pushed();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_pushed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_pushed",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_pushed" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl::pushed(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_pushed(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_pushed__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_pushed__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_pushed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::pushed()\n"
    "    Fl::pushed(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_focus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_focus",0,0)) SWIG_fail;
  result = (Fl_Widget *)Fl::focus();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_focus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_focus",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_focus" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl::focus(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_focus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_focus__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_focus__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_focus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::focus()\n"
    "    Fl::focus(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_add_system_handler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_System_Handler arg1 = (Fl_System_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_add_system_handler",2,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_add_system_handler" "', argument " "1"" of type '" "Fl_System_Handler""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_add_system_handler" "', argument " "2"" of type '" "void *""'"); 
  }
  Fl::add_system_handler(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_remove_system_handler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_System_Handler arg1 = (Fl_System_Handler) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_remove_system_handler",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void_p_void__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_remove_system_handler" "', argument " "1"" of type '" "Fl_System_Handler""'"); 
    }
  }
  Fl::remove_system_handler(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_dispatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Event_Dispatch arg1 = (Fl_Event_Dispatch) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_dispatch",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_int_p_Fl_Window__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_event_dispatch" "', argument " "1"" of type '" "Fl_Event_Dispatch""'"); 
    }
  }
  Fl::event_dispatch(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_dispatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Event_Dispatch result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_dispatch",0,0)) SWIG_fail;
  result = (Fl_Event_Dispatch)Fl::event_dispatch();
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_p_Fl_Window__int);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_dispatch(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_event_dispatch__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_event_dispatch__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_event_dispatch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::event_dispatch(Fl_Event_Dispatch)\n"
    "    Fl::event_dispatch()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_copy",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_copy" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_copy" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  Fl::copy((char const *)arg1,arg2,arg3,(char const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_copy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 = (int) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_copy",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_copy" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_copy" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  Fl::copy((char const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_copy(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_Fl_copy__SWIG_1(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_copy__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::copy(char const *,int,int,char const *)\n"
    "    Fl::copy(char const *,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_paste__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_paste",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_paste" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_paste" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  Fl::paste(*arg1,arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_paste__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_paste",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_paste" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  Fl::paste(*arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_add_clipboard_notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clipboard_Notify_Handler arg1 = (Fl_Clipboard_Notify_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_add_clipboard_notify",1,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_add_clipboard_notify" "', argument " "1"" of type '" "Fl_Clipboard_Notify_Handler""'"); 
    }
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_add_clipboard_notify" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  Fl::add_clipboard_notify(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_remove_clipboard_notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clipboard_Notify_Handler arg1 = (Fl_Clipboard_Notify_Handler) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_remove_clipboard_notify",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_remove_clipboard_notify" "', argument " "1"" of type '" "Fl_Clipboard_Notify_Handler""'"); 
    }
  }
  Fl::remove_clipboard_notify(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_clipboard_contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_clipboard_contains",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_clipboard_contains" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)Fl::clipboard_contains((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_dnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_dnd",0,0)) SWIG_fail;
  result = (int)Fl::dnd();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_selection_owner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_selection_owner",0,0)) SWIG_fail;
  result = (Fl_Widget *)Fl::selection_owner();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_selection_owner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_selection_owner",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_selection_owner" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl::selection_owner(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_selection_owner(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_selection_owner__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_selection_owner__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_selection_owner'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::selection_owner()\n"
    "    Fl::selection_owner(Fl_Widget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_selection(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_selection",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_selection" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_selection" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_selection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_selection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  Fl::selection(*arg1,(char const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_paste__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_paste",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_paste" "', argument " "1"" of type '" "Fl_Widget &""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl::paste(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_paste(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_paste__SWIG_2(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_paste__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_paste__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_paste'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::paste(Fl_Widget &,int,char const *)\n"
    "    Fl::paste(Fl_Widget &,int)\n"
    "    Fl::paste(Fl_Widget &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_x",0,0)) SWIG_fail;
  result = (int)Fl::x();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_y",0,0)) SWIG_fail;
  result = (int)Fl::y();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_w",0,0)) SWIG_fail;
  result = (int)Fl::w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_h",0,0)) SWIG_fail;
  result = (int)Fl::h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_count",0,0)) SWIG_fail;
  result = (int)Fl::screen_count();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_xywh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_xywh",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_xywh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 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 val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_xywh",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_screen_xywh" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_screen_xywh" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_xywh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_xywh",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_screen_xywh" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_xywh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 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 val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_xywh",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_xywh" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_screen_xywh" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_screen_xywh" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_screen_xywh" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_screen_xywh" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  Fl::screen_xywh(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_xywh(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    return _wrap_Fl_screen_xywh__SWIG_0(self, args);
  }
  if (argc == 5) {
    return _wrap_Fl_screen_xywh__SWIG_2(self, args);
  }
  if (argc == 6) {
    return _wrap_Fl_screen_xywh__SWIG_1(self, args);
  }
  if (argc == 8) {
    return _wrap_Fl_screen_xywh__SWIG_3(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_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_Fl_screen_num__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_num",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_screen_num" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_screen_num" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)Fl::screen_num(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_num__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_num",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_screen_num" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_screen_num" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_screen_num" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_screen_num" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)Fl::screen_num(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_num(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_screen_num__SWIG_0(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_screen_num__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_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_Fl_screen_dpi(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_dpi",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_dpi" "', argument " "1"" of type '" "float &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_dpi" "', argument " "1"" of type '" "float &""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_dpi" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_dpi" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_screen_dpi" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  Fl::screen_dpi(*arg1,*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_work_area__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 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 val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_work_area",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_work_area" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_work_area" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_screen_work_area" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_screen_work_area" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_screen_work_area" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_screen_work_area" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  Fl::screen_work_area(*arg1,*arg2,*arg3,*arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_work_area__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_work_area",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_work_area" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_work_area" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_screen_work_area" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_screen_work_area" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_screen_work_area" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  Fl::screen_work_area(*arg1,*arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_work_area__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_screen_work_area",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_screen_work_area" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_screen_work_area" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_screen_work_area" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_screen_work_area" "', argument " "4"" of type '" "int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_screen_work_area" "', argument " "4"" of type '" "int &""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  Fl::screen_work_area(*arg1,*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_screen_work_area(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    return _wrap_Fl_screen_work_area__SWIG_2(self, args);
  }
  if (argc == 5) {
    return _wrap_Fl_screen_work_area__SWIG_1(self, args);
  }
  if (argc == 6) {
    return _wrap_Fl_screen_work_area__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_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_Fl_set_color__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_color",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_set_color" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_set_color" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = static_cast< uchar >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_set_color" "', argument " "4"" of type '" "uchar""'");
  } 
  arg4 = static_cast< uchar >(val4);
  Fl::set_color(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_color",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_set_color" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  Fl::set_color(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_set_color__SWIG_1(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_set_color__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_set_color'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::set_color(Fl_Color,uchar,uchar,uchar)\n"
    "    Fl::set_color(Fl_Color,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_get_color(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_get_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_get_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  Fl::get_color(arg1,*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
  } 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));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_free_color(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_free_color",1,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_free_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_free_color" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  Fl::free_color(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_get_font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_get_font",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_get_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  result = (char *)Fl::get_font(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_get_font_name(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  char *result = 0 ;
  
  arg2 = &temp2;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_get_font_name",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_get_font_name" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  result = (char *)Fl::get_font_name(arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_font__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_font",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_set_font" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  Fl::set_font(arg1,(char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_font__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  Fl_Font arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_font",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_set_font" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  Fl::set_font(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_font(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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_set_font__SWIG_1(self, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_set_font__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_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_Fl_set_fonts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_fonts",0,1,&obj0)) SWIG_fail;
  if (obj0) {
    res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_set_fonts" "', argument " "1"" of type '" "char const *""'");
    }
    arg1 = reinterpret_cast< char * >(buf1);
  }
  result = (Fl_Font)Fl::set_fonts((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_labeltype(PyObject *SWIGUNUSEDPARM(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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_labeltype",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_labeltype" "', argument " "1"" of type '" "Fl_Labeltype""'");
  } 
  arg1 = static_cast< Fl_Labeltype >(val1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_set_labeltype" "', argument " "2"" of type '" "Fl_Label_Draw_F *""'"); 
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_q_const__Fl_Label_r_int_r_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_set_labeltype" "', argument " "3"" of type '" "Fl_Label_Measure_F *""'"); 
    }
  }
  Fl::set_labeltype(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_get_boxtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Box_Draw_F *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_get_boxtype",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_get_boxtype" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (Fl_Box_Draw_F *)Fl::get_boxtype(arg1);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_int_int_int_unsigned_int__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_boxtype__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  Fl_Box_Draw_F *arg2 = (Fl_Box_Draw_F *) 0 ;
  uchar arg3 ;
  uchar arg4 ;
  uchar arg5 ;
  uchar arg6 ;
  int val1 ;
  int ecode1 = 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_boxtype",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_boxtype" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_int_int_int_int_unsigned_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_set_boxtype" "', argument " "2"" of type '" "Fl_Box_Draw_F *""'"); 
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_set_boxtype" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = static_cast< uchar >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_set_boxtype" "', argument " "4"" of type '" "uchar""'");
  } 
  arg4 = static_cast< uchar >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_set_boxtype" "', argument " "5"" of type '" "uchar""'");
  } 
  arg5 = static_cast< uchar >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_set_boxtype" "', argument " "6"" of type '" "uchar""'");
  } 
  arg6 = static_cast< uchar >(val6);
  Fl::set_boxtype(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_boxtype__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  Fl_Boxtype arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_boxtype",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_boxtype" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_set_boxtype" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  Fl::set_boxtype(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_boxtype(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_set_boxtype__SWIG_1(self, args);
  }
  if (argc == 6) {
    return _wrap_Fl_set_boxtype__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_set_boxtype'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::set_boxtype(Fl_Boxtype,Fl_Box_Draw_F *,uchar,uchar,uchar,uchar)\n"
    "    Fl::set_boxtype(Fl_Boxtype,Fl_Boxtype)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_box_dx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_box_dx",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_box_dx" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (int)Fl::box_dx(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_box_dy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_box_dy",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_box_dy" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (int)Fl::box_dy(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_box_dw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_box_dw",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_box_dw" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (int)Fl::box_dw(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_box_dh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Boxtype arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_box_dh",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_box_dh" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  result = (int)Fl::box_dh(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_draw_box_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_draw_box_active",0,0)) SWIG_fail;
  result = (int)Fl::draw_box_active();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_box_color(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_box_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_box_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  result = (Fl_Color)Fl::box_color(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_box_color(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_box_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_set_box_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  Fl::set_box_color(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_abort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Abort_Handler arg1 = (Fl_Abort_Handler) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_abort",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_v_______void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_set_abort" "', argument " "1"" of type '" "Fl_Abort_Handler""'"); 
    }
  }
  Fl::set_abort(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_default_atclose(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_default_atclose",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_default_atclose" "', argument " "1"" of type '" "Fl_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_default_atclose" "', argument " "2"" of type '" "void *""'"); 
  }
  Fl::default_atclose(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_atclose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Atclose_Handler arg1 = (Fl_Atclose_Handler) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_atclose",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_Fl_Window_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_set_atclose" "', argument " "1"" of type '" "Fl_Atclose_Handler""'"); 
    }
  }
  Fl::set_atclose(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_shift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_shift",0,0)) SWIG_fail;
  result = (int)Fl::event_shift();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_ctrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_ctrl",0,0)) SWIG_fail;
  result = (int)Fl::event_ctrl();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_command(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_command",0,0)) SWIG_fail;
  result = (int)Fl::event_command();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_alt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_alt",0,0)) SWIG_fail;
  result = (int)Fl::event_alt();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_buttons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_buttons",0,0)) SWIG_fail;
  result = (int)Fl::event_buttons();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_button1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_button1",0,0)) SWIG_fail;
  result = (int)Fl::event_button1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_button2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_button2",0,0)) SWIG_fail;
  result = (int)Fl::event_button2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_event_button3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_event_button3",0,0)) SWIG_fail;
  result = (int)Fl::event_button3();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_set_idle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Old_Idle_Handler arg1 = (Fl_Old_Idle_Handler) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_set_idle",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f___void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_set_idle" "', argument " "1"" of type '" "Fl_Old_Idle_Handler""'"); 
    }
  }
  Fl::set_idle(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_release",0,0)) SWIG_fail;
  Fl::release();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_visible_focus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_visible_focus",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_visible_focus" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  Fl::visible_focus(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_visible_focus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_visible_focus",0,0)) SWIG_fail;
  result = (int)Fl::visible_focus();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_visible_focus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_visible_focus__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_visible_focus__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_visible_focus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::visible_focus(int)\n"
    "    Fl::visible_focus()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_dnd_text_ops__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_dnd_text_ops",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_dnd_text_ops" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  Fl::dnd_text_ops(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_dnd_text_ops__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_dnd_text_ops",0,0)) SWIG_fail;
  result = (int)Fl::dnd_text_ops();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_dnd_text_ops(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_dnd_text_ops__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_dnd_text_ops__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_dnd_text_ops'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::dnd_text_ops(int)\n"
    "    Fl::dnd_text_ops()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_awake__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Awake_Handler arg1 = (Fl_Awake_Handler) 0 ;
  void *arg2 = (void *) 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_awake",1,2,&obj0,&obj1)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Fl_awake" "', argument " "1"" of type '" "Fl_Awake_Handler""'"); 
    }
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_awake" "', argument " "2"" of type '" "void *""'"); 
    }
  }
  result = (int)Fl::awake(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_delete_widget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_delete_widget",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_delete_widget" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl::delete_widget(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_do_widget_deletion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_do_widget_deletion",0,0)) SWIG_fail;
  Fl::do_widget_deletion();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_watch_widget_pointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget **arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_watch_widget_pointer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_watch_widget_pointer" "', argument " "1"" of type '" "Fl_Widget *&""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_watch_widget_pointer" "', argument " "1"" of type '" "Fl_Widget *&""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget ** >(argp1);
  Fl::watch_widget_pointer(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_release_widget_pointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget **arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_release_widget_pointer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_p_Fl_Widget,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_release_widget_pointer" "', argument " "1"" of type '" "Fl_Widget *&""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_release_widget_pointer" "', argument " "1"" of type '" "Fl_Widget *&""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget ** >(argp1);
  Fl::release_widget_pointer(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_clear_widget_pointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_clear_widget_pointer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_clear_widget_pointer" "', argument " "1"" of type '" "Fl_Widget const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl::clear_widget_pointer((Fl_Widget const *)arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_use_high_res_GL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_use_high_res_GL",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_use_high_res_GL" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  Fl::use_high_res_GL(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_use_high_res_GL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_use_high_res_GL",0,0)) SWIG_fail;
  result = (int)Fl::use_high_res_GL();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_use_high_res_GL(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_use_high_res_GL__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_use_high_res_GL__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_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_Fl_lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_lock",0,0)) SWIG_fail;
  Fl_cond_lock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_unlock",0,0)) SWIG_fail;
  Fl_cond_unlock();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_awake__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  void *arg1 = (void *) 0 ;
  int res1 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_awake",0,1,&obj0)) SWIG_fail;
  if (obj0) {
    res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_awake" "', argument " "1"" of type '" "void *""'"); 
    }
  }
  Fl_cond_awake__SWIG_1(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_awake(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 0) && (argc <= 1)) {
    int _v = 0;
    if (argc > 0) {
      {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
      }
      if (!_v) goto check_1;
    }
    return _wrap_Fl_awake__SWIG_1(self, args);
  }
check_1:
  
  if ((argc >= 1) && (argc <= 2)) {
    return _wrap_Fl_awake__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_awake'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl::awake(Fl_Awake_Handler,void *)\n"
    "    Fl::Fl_cond_awake__SWIG_1(void *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_thread_message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_thread_message",0,0)) SWIG_fail;
  Fl_cond_thread_message();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl *arg1 = (Fl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl" "', argument " "1"" of type '" "Fl *""'"); 
  }
  arg1 = reinterpret_cast< Fl * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Widget_Tracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Widget_Tracker *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Widget_Tracker",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Widget_Tracker" "', argument " "1"" of type '" "Fl_Widget *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget * >(argp1);
  result = (Fl_Widget_Tracker *)new Fl_Widget_Tracker(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Widget_Tracker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Widget_Tracker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Tracker *arg1 = (Fl_Widget_Tracker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Widget_Tracker",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget_Tracker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Widget_Tracker" "', argument " "1"" of type '" "Fl_Widget_Tracker *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget_Tracker * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Tracker_widget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Tracker *arg1 = (Fl_Widget_Tracker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_Tracker_widget",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget_Tracker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Tracker_widget" "', argument " "1"" of type '" "Fl_Widget_Tracker *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget_Tracker * >(argp1);
  result = (Fl_Widget *)(arg1)->widget();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_Widget_Tracker_deleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Tracker *arg1 = (Fl_Widget_Tracker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_Tracker_deleted",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget_Tracker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Tracker_deleted" "', argument " "1"" of type '" "Fl_Widget_Tracker *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget_Tracker * >(argp1);
  result = (int)(arg1)->deleted();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Widget_Tracker_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget_Tracker *arg1 = (Fl_Widget_Tracker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Widget_Tracker_exists",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Widget_Tracker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Widget_Tracker_exists" "', argument " "1"" of type '" "Fl_Widget_Tracker *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Widget_Tracker * >(argp1);
  result = (int)(arg1)->exists();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Widget_Tracker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Widget_Tracker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_pyFLTK_controlIdleCallbacks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"pyFLTK_controlIdleCallbacks",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pyFLTK_controlIdleCallbacks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  pyFLTK_controlIdleCallbacks(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_name",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_filename_name" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (char *)fl_filename_name((char const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_ext",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_filename_ext" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (char *)fl_filename_ext((char const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_setext__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_setext",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_setext" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (char *)fl_filename_setext(arg1,arg2,(char const *)arg3);
  resultobj = SWIG_FromCharPtr((const char *)result);
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_expand__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_expand",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_expand" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (int)fl_filename_expand(arg1,arg2,(char const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_absolute",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_absolute" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (int)fl_filename_absolute(arg1,arg2,(char const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_relative",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_relative" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (int)fl_filename_relative(arg1,arg2,(char const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_match(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_match",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_filename_match" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_filename_match" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)fl_filename_match((char const *)arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_isdir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_isdir",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_filename_isdir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)fl_filename_isdir((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_setext__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_setext",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (char *)fl_filename_setext(arg1,(char const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_setext(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_fl_filename_setext__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_fl_filename_setext__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_expand",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)fl_filename_expand(arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_expand(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_fl_filename_expand__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_fl_filename_expand__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_absolute",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)fl_filename_absolute(arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_absolute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_fl_filename_absolute__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_fl_filename_absolute__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_relative",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_relative" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  result = (int)fl_filename_relative(arg1,arg2,(char const *)arg3,(char const *)arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_relative",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)fl_filename_relative(arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg1[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_filename_relative(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_fl_filename_relative__SWIG_2(self, args);
  }
  if (argc == 3) {
    return _wrap_fl_filename_relative__SWIG_0(self, args);
  }
  if (argc == 4) {
    return _wrap_fl_filename_relative__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  dirent ***arg1 = (dirent ***) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_filename_free_list",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< dirent *** >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_filename_free_list" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  fl_filename_free_list(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_open_uri(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_open_uri",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_open_uri" "', argument " "2"" of type '" "char *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_open_uri" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)fl_open_uri((char const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_decode_uri",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_decode_uri" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_decode_uri(arg1);
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_bounds(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_bounds",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_bounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_bounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bounds(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_minimum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_minimum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  result = (double)((Fl_Valuator const *)arg1)->minimum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_minimum__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_minimum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_minimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->minimum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_minimum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Valuator_minimum__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Valuator_minimum__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_maximum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  result = (double)((Fl_Valuator const *)arg1)->maximum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_maximum__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_maximum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_maximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->maximum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_maximum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Valuator_maximum__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Valuator_maximum__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_range",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_range" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_range" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->range(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_step",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_step" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->step(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_step",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_step" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->step(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_2(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_step",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->step(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_step",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  result = (double)((Fl_Valuator const *)arg1)->step();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_step(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Valuator_step__SWIG_3(self, args);
  }
  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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Valuator_step__SWIG_2(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Valuator_step__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_precision",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_precision" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->precision(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  result = (double)((Fl_Valuator const *)arg1)->value();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_value__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->value(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Valuator_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Valuator_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 temp2[1024+1] ;
  char *t2 = 0 ;
  size_t n2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_format",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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""'");
  }
  if ( n2 > (size_t) 1024 ) n2 = (size_t) 1024;
  memcpy(temp2, t2, sizeof(char)*n2);
  if (alloc2 == SWIG_NEWOBJ) delete[] t2;
  temp2[n2 - 1] = 0;                                                             
  arg2 = (char *) temp2;
  result = (int)(arg1)->format(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  arg2[1024] = 0;
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg2));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_round(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_round",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_round" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->round(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_clamp(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_clamp",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_clamp" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->clamp(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Valuator_increment(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Valuator_increment",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Valuator_increment" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Valuator_increment" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->increment(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Valuator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Valuator *arg1 = (Fl_Valuator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Valuator",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Valuator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Valuator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Valuator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Adjuster_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Adjuster *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Adjuster_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Adjuster *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Adjuster *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Adjuster_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Adjuster * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Adjuster_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Adjuster *>(arg1);
    if (upcall) {
      result = (int)(darg)->handleSwigPublic(arg2);
    } else {
      result = (int)(darg)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Adjuster(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Adjuster *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Adjuster",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Adjuster" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Adjuster" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Adjuster" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Adjuster" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Adjuster_soft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Adjuster * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Adjuster_soft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->soft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_soft__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Adjuster_soft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Adjuster * >(argp1);
  result = (int)((Fl_Adjuster const *)arg1)->soft();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Adjuster_soft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Adjuster_soft__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Adjuster_soft__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Adjuster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Adjuster",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Adjuster * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Adjuster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Adjuster *arg1 = (Fl_Adjuster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Adjuster",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Adjuster, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

SWIGINTERN PyObject *_wrap_fl_beep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) FL_BEEP_DEFAULT ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_beep",0,1,&obj0)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_int(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_beep" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  fl_beep(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message__varargs__(PyObject *SWIGUNUSEDPARM(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 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"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 = reinterpret_cast< char * >(buf1);
  fl_message((char const *)arg1,arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message(PyObject *SWIGUNUSEDPARM(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);
  Py_XDECREF(newargs);
  Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_alert__varargs__(PyObject *SWIGUNUSEDPARM(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 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"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 = reinterpret_cast< char * >(buf1);
  fl_alert((char const *)arg1,arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_alert(PyObject *SWIGUNUSEDPARM(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);
  Py_XDECREF(newargs);
  Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_ask__varargs__(PyObject *SWIGUNUSEDPARM(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;
  
  if(!PyArg_UnpackTuple(args,(char *)"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 = reinterpret_cast< char * >(buf1);
  result = (int)fl_ask((char const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_ask(PyObject *SWIGUNUSEDPARM(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);
  Py_XDECREF(newargs);
  Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_choice__varargs__(PyObject *SWIGUNUSEDPARM(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;
  
  if(!PyArg_UnpackTuple(args,(char *)"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 = reinterpret_cast< 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 = reinterpret_cast< 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 = reinterpret_cast< 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 = reinterpret_cast< char * >(buf4);
  result = (int)fl_choice((char const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
  resultobj = SWIG_From_int(static_cast< 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 *SWIGUNUSEDPARM(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);
  Py_XDECREF(newargs);
  Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_message_icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_message_icon",0,0)) SWIG_fail;
  result = (Fl_Widget *)fl_message_icon();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  Fl_Fontsize arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_message_font",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_message_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_message_font" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  fl_message_font(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_hotspot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_message_hotspot",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_message_hotspot" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  fl_message_hotspot(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_hotspot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_message_hotspot",0,0)) SWIG_fail;
  result = (int)fl_message_hotspot();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_hotspot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_fl_message_hotspot__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_fl_message_hotspot__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_title(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_message_title",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_title" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_message_title((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_message_title_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_message_title_default",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_title_default" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_message_title_default((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}



#pragma GCC diagnostic pop

SWIGINTERN PyObject *_wrap_fl_input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_input",1,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_input" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_input" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
  }
  result = (char *)fl_vararg_input((char const *)arg1,(char const *)arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_password",1,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_password" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_password" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
  }
  result = (char *)fl_vararg_password((char const *)arg1,(char const *)arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_no_get",0,0)) SWIG_fail;
  result = (char *)fl_no_get();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_yes_get",0,0)) SWIG_fail;
  result = (char *)fl_yes_get();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_ok_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_ok_get",0,0)) SWIG_fail;
  result = (char *)fl_ok_get();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cancel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_cancel_get",0,0)) SWIG_fail;
  result = (char *)fl_cancel_get();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_close_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_close_get",0,0)) SWIG_fail;
  result = (char *)fl_close_get();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_no_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_no_set",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_no_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_no_set((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_yes_set",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_yes_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_yes_set((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_ok_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_ok_set",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_ok_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_ok_set((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cancel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_cancel_set",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_cancel_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_cancel_set((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_close_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_close_set",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_close_set" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_close_set((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mt_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_mt_message" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_mt_message((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_alert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mt_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_mt_alert" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_mt_alert((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_ask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mt_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_mt_ask" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)fl_mt_ask((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mt_choice(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mt_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_mt_choice" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_mt_choice" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  result = (int)fl_mt_choice((char const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
  resultobj = SWIG_From_int(static_cast< 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mt_input",1,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_mt_input" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  }
  result = (char *)fl_mt_input((char const *)arg1,(char const *)arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mt_password",1,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_mt_password" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  }
  result = (char *)fl_mt_password((char const *)arg1,(char const *)arg2);
  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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Bitmap *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Bitmap",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  {
    /* Check if the input support the buffer protocol */
    Py_ssize_t size_buffer;
    const void * buffer;
    int failure = PyObject_AsReadBuffer(obj1,&buffer,&size_buffer);
    if (!failure) {
      // work with array object
      arg2 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_AsReadBuffer
      PyErr_Clear();
      size_buffer=0;
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(obj1)) {
        int size = PyList_Size(obj1);
        int i = 0;
        arg2 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Bitmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Bitmap" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  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); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Bitmap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Bitmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Bitmap * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Bitmap_copy",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Bitmap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Bitmap_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Bitmap_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Image *)(arg1)->Fl_Bitmap::copy(arg2,arg3);
    } else {
      result = (Fl_Image *)(arg1)->copy(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Bitmap_copy",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Bitmap * >(argp1);
  result = (Fl_Image *)(arg1)->copy();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Bitmap_copy__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Bitmap_copy__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Bitmap_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Bitmap::copy(int,int)\n"
    "    Fl_Bitmap::copy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Bitmap_draw",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Bitmap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Bitmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Bitmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Bitmap_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Bitmap_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Bitmap_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Bitmap_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Bitmap_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Bitmap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Bitmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Bitmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->draw(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_Bitmap_draw__SWIG_1(self, args);
  }
  if ((argc >= 5) && (argc <= 7)) {
    return _wrap_Fl_Bitmap_draw__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Bitmap_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Bitmap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Bitmap::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Bitmap_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Bitmap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Bitmap::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Bitmap_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Bitmap_label__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Bitmap_uncache",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Bitmap * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Bitmap::uncache();
    } else {
      (arg1)->uncache();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Bitmap *arg1 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Bitmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Bitmap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_BMP_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_BMP_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_BMP_Image",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  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); 
  }
  
  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_delete_Fl_BMP_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_BMP_Image *arg1 = (Fl_BMP_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_BMP_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_BMP_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_BMP_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_BMP_Image *arg1 = (Fl_BMP_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_BMP_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_BMP_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Box_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Box *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Box_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Box *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Box__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Box *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Box",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Box" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Box" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Fl_Box *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Box",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Box" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Box" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_AsCharPtrAndSize(obj6, &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 = reinterpret_cast< char * >(buf7);
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Box__SWIG_0(self, args);
  }
  if (argc == 7) {
    return _wrap_new_Fl_Box__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Box_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Box * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Box_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Box::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Box(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Box * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Box(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Box *arg1 = (Fl_Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Box, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fl_old_shortcut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Shortcut result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_old_shortcut",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_old_shortcut" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (Fl_Shortcut)fl_old_shortcut((char const *)arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Button::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->value(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  result = (char)((Fl_Button const *)arg1)->value();
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Button_value__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Button_value__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_set",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  result = (int)(arg1)->set();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  result = (int)(arg1)->clear();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_setonly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_setonly",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  (arg1)->setonly();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_shortcut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  result = (int)((Fl_Button const *)arg1)->shortcut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_shortcut__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_shortcut",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->shortcut(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_box__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_down_box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  result = (Fl_Boxtype)((Fl_Button const *)arg1)->down_box();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_box__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  Fl_Boxtype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_down_box",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_down_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  (arg1)->down_box(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_box(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Button_down_box__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Button_down_box__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_shortcut",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->shortcut((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_shortcut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Button_shortcut__SWIG_0(self, args);
  }
  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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Button_shortcut__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_down_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  result = (Fl_Color)((Fl_Button const *)arg1)->down_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Button_down_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Button_down_color" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->down_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Button_down_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Button_down_color__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Button_down_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Button *arg1 = (Fl_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FL_CHART_ENTRY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FL_CHART_ENTRY *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_FL_CHART_ENTRY",0,0)) SWIG_fail;
  result = (FL_CHART_ENTRY *)new FL_CHART_ENTRY();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FL_CHART_ENTRY *arg1 = (FL_CHART_ENTRY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_FL_CHART_ENTRY",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< FL_CHART_ENTRY * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FL_CHART_ENTRY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FL_CHART_ENTRY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Chart_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Chart *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Chart *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Chart(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Chart *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Chart",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Chart" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Chart" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Chart" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Chart" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Chart",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_add(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_add",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_add" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (obj2) {
    res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Chart_add" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  (arg1)->add(arg2,(char const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_insert",3,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_insert" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Chart_insert" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  (arg1)->insert(arg2,arg3,(char const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_replace(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_replace",3,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_replace" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Chart_replace" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  (arg1)->replace(arg2,arg3,(char const *)arg4,arg5);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_bounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_bounds",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< double * >(argp3);
  ((Fl_Chart const *)arg1)->bounds(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_bounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_bounds",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_bounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_bounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bounds(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_bounds(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_Chart_bounds__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  result = (int)((Fl_Chart const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_size",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Chart_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->size(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Chart_size__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Chart_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_maxsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  result = (int)((Fl_Chart const *)arg1)->maxsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_maxsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_maxsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_maxsize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->maxsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_maxsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Chart_maxsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Chart_maxsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  result = (Fl_Font)((Fl_Chart const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Chart_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Chart_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  result = (Fl_Fontsize)((Fl_Chart const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Chart_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Chart_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  result = (Fl_Color)((Fl_Chart const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Chart_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Chart_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_autosize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  result = (uchar)((Fl_Chart const *)arg1)->autosize();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_autosize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Chart_autosize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Chart * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Chart_autosize" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->autosize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Chart_autosize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Chart_autosize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Chart_autosize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_Chart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Chart *arg1 = (Fl_Chart *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Chart",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Chart, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Check_Browser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Check_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Check_Browser",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Check_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Check_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Check_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Check_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Check_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_remove(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->remove(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_add__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->add((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_add",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Check_Browser_add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->add((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_add(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Check_Browser_add__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Check_Browser_add__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_nitems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_nitems",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  result = (int)((Fl_Check_Browser const *)arg1)->nitems();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_nchecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_nchecked",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  result = (int)((Fl_Check_Browser const *)arg1)->nchecked();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_checked__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_checked",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_checked" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Check_Browser const *)arg1)->checked(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_checked__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_checked",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_checked" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Check_Browser_checked" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->checked(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_checked(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Check_Browser_checked__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Check_Browser_checked__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_set_checked",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_set_checked" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->set_checked(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_check_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_check_all",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  (arg1)->check_all();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_check_none(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_check_none",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  (arg1)->check_none();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  result = (int)((Fl_Check_Browser const *)arg1)->value();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)((Fl_Check_Browser const *)arg1)->text(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      result = (int)(darg)->handleSwigPublic(arg2);
    } else {
      result = (int)(darg)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Check_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Check_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Check_Browser::item_first");
    } else {
      result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_first();
    }
  } 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Check_Browser::item_next");
    } else {
      result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_next(arg2);
    }
  } 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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_prev",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Check_Browser::item_prev");
    } else {
      result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_prev(arg2);
    }
  } 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_last(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Check_Browser::item_height");
    } else {
      result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_height(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_width(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Check_Browser::item_width");
    } else {
      result = (int)((SwigDirector_Fl_Check_Browser const *)darg)->item_width(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_quick_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_quick_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Check_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Check_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Check_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Check_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Check_Browser::item_draw");
    } else {
      ((SwigDirector_Fl_Check_Browser const *)darg)->item_draw(arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    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&) {
    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_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2,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);
  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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      (darg)->item_swapSwigPublic(arg2,arg3);
    } else {
      (darg)->item_swap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_at",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Check_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_atSwigPublic(arg2);
    } else {
      result = (void *)((SwigDirector_Fl_Check_Browser const *)darg)->item_at(arg2);
    }
  } 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_full_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_full_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_full_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_full_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_incr_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_incr_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_select(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Browser *arg1 = (Fl_Check_Browser *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_select",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 *""'"); 
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Check_Browser_item_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    if (upcall) {
      (darg)->item_selectSwigPublic(arg2,arg3);
    } else {
      (darg)->item_select(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Check_Browser_item_selected(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Browser_item_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Check_Browser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Check_Browser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Light_Button_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Light_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Light_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Light_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Light_Button_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Light_Button_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Light_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Light_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Light_Button::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Light_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Light_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Light_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Light_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Light_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Light_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Light_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Light_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Light_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Light_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Light_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Light_Button *arg1 = (Fl_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Light_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Light_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Check_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Check_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Check_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Check_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Check_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Check_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Check_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Check_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Button *arg1 = (Fl_Check_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Check_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Check_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Check_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Button *arg1 = (Fl_Check_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Check_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Check_Button *arg1 = (Fl_Check_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Check_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Check_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Check_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Check_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Menu_(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Menu_ *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Menu_",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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;
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Menu_",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__item_pathname(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__item_pathname",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__item_pathname" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &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 = reinterpret_cast< Fl_Menu_Item * >(argp4);
  }
  result = (int)((Fl_Menu_ const *)arg1)->item_pathname(arg2,arg3,(Fl_Menu_Item const *)arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__picked(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__picked",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  result = (Fl_Menu_Item *)(arg1)->picked((Fl_Menu_Item const *)arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__find_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (Fl_Menu_Item *)(arg1)->find_item((char const *)arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__find_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 *""'"); 
    }
  }
  result = (Fl_Menu_Item *)(arg1)->find_item(arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Menu__find_item__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_index__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__find_index",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)((Fl_Menu_ const *)arg1)->find_index((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_index__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__find_index",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  result = (int)((Fl_Menu_ const *)arg1)->find_index((Fl_Menu_Item const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_index__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__find_index",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 *""'"); 
    }
  }
  result = (int)((Fl_Menu_ const *)arg1)->find_index(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__find_index(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Menu__find_index__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__test_shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Menu_Item *)(arg1)->test_shortcut();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__menu",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Menu_Item *)((Fl_Menu_ const *)arg1)->menu();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__copy",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2,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 *""'"); 
    }
  }
  (arg1)->copy((Fl_Menu_Item const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__insert",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu__insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    int res = SWIG_ConvertFunctionPtr(obj4, (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 (obj5) {
    res6 = SWIG_ConvertPtr(obj5,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 (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu__insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  result = (int)(arg1)->insert(arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__add",4,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(obj3, (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 (obj4) {
    res5 = SWIG_ConvertPtr(obj4,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 (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Menu__add" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  result = (int)(arg1)->add((char const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__insert",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  {
    int res = SWIG_ConvertFunctionPtr(obj4, (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 (obj5) {
    res6 = SWIG_ConvertPtr(obj5,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 (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu__insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  result = (int)(arg1)->insert(arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_int(static_cast< 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) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Menu__insert__SWIG_0(self, args);
  }
check_1:
  
  if ((argc >= 5) && (argc <= 7)) {
    return _wrap_Fl_Menu__insert__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->add((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (int)((Fl_Menu_ const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__size__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__size",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->size(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__size__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Menu__size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__clear_submenu(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__clear_submenu",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__clear_submenu" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->clear_submenu(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__replace(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__replace",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  (arg1)->replace(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__remove(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__shortcut(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__shortcut",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__shortcut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->shortcut(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__mode__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__mode",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu__mode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->mode(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__mode__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__mode",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Menu_ const *)arg1)->mode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__mode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__mode__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Menu__mode__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__mvalue",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Menu_Item *)((Fl_Menu_ const *)arg1)->mvalue();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (int)((Fl_Menu_ const *)arg1)->value();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__value__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->value(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__text",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (char *)((Fl_Menu_ const *)arg1)->text();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__text__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)((Fl_Menu_ const *)arg1)->text(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__text(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__text__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__text__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Font)((Fl_Menu_ const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Fontsize)((Fl_Menu_ const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Color)((Fl_Menu_ const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__down_box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Boxtype)((Fl_Menu_ const *)arg1)->down_box();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_box__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  Fl_Boxtype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__down_box",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__down_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  (arg1)->down_box(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_box(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__down_box__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__down_box__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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__down_color__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__down_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (Fl_Color)((Fl_Menu_ const *)arg1)->down_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__down_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu__down_color" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->down_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__down_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__down_color__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__down_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__setonly",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  (arg1)->setonly(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__copy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__copy",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  arg2 = obj1;
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Menu__copy__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__copy(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_Fl_Menu__copy__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__menu",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  arg2 = obj1;
  Fl_Menu__menu__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__add__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__add",4,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  arg2 = obj1;
  arg3 = obj2;
  arg4 = obj3;
  if (obj4) {
    arg5 = obj4;
  }
  if (obj5) {
    arg6 = obj5;
  }
  result = (int)Fl_Menu__add__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__add(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__add__SWIG_1(self, args);
  }
  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, args);
  }
check_2:
  
  if ((argc >= 4) && (argc <= 6)) {
    return _wrap_Fl_Menu__add__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu__menu",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_ * >(argp1);
  result = (PyObject *)Fl_Menu__menu__SWIG_2(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu__menu(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__menu__SWIG_2(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu__menu__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu__menu__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_ *arg1 = (Fl_Menu_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Menu_",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Menu_, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Choice_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Choice *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Choice_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Choice *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Choice_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Choice * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Choice_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Choice::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Choice(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Choice *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Choice",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Choice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Choice" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Choice" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Choice" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Choice_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Choice * >(argp1);
  result = (int)((Fl_Choice const *)arg1)->value();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_value__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Choice_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Choice * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Choice_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->value(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Choice_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Choice_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Choice_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Choice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Choice",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Choice * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Choice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Choice *arg1 = (Fl_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Choice",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Choice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Clock_Output_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Clock_Output *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_Output_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Clock_Output *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Clock_Output(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Clock_Output *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Clock_Output",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Clock_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Clock_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Clock_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Clock_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_Output_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock_Output * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Clock_Output_value" "', argument " "2"" of type '" "ulong""'");
  } 
  arg2 = static_cast< ulong >(val2);
  (arg1)->value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_Output_value",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock_Output * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Clock_Output_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Clock_Output_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Clock_Output_value" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->value(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_value__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  ulong result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_Output_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock_Output * >(argp1);
  result = (ulong)((Fl_Clock_Output const *)arg1)->value();
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Clock_Output_value__SWIG_2(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Clock_Output_value__SWIG_0(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_Clock_Output_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_Output_hour",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock_Output * >(argp1);
  result = (int)((Fl_Clock_Output const *)arg1)->hour();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_Output_minute",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock_Output * >(argp1);
  result = (int)((Fl_Clock_Output const *)arg1)->minute();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Clock_Output_second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_Output_second",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock_Output * >(argp1);
  result = (int)((Fl_Clock_Output const *)arg1)->second();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Clock_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Clock_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock_Output * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Clock_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock_Output *arg1 = (Fl_Clock_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Clock_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Clock_Output, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Clock_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Clock_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Clock::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Clock__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Clock *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Clock",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Clock" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Clock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Clock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Clock" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Fl_Clock *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Clock",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Clock" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Clock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Clock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Clock" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Clock" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_AsCharPtrAndSize(obj6, &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 = reinterpret_cast< char * >(buf7);
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Clock__SWIG_0(self, args);
  }
  if (argc == 7) {
    return _wrap_new_Fl_Clock__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Clock",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Clock * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Clock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Clock",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Clock *arg1 = (Fl_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Clock *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Clock_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Clock *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Clock, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Value_Input_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Value_Input::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Value_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Value_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Value_Input_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Value_Input_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Value_Input_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Value_Input::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Value_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Value_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Value_Input",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Value_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Value_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Value_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Value_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Value_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_soft__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_soft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_soft" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->soft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_soft__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_soft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  result = (char)((Fl_Value_Input const *)arg1)->soft();
  resultobj = SWIG_NewPointerObj((new char(static_cast< const 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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Input_soft__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Input_soft__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  result = (int)((Fl_Value_Input const *)arg1)->shortcut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_shortcut__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_shortcut",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->shortcut(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_shortcut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Input_shortcut__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Input_shortcut__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  result = (Fl_Font)((Fl_Value_Input const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Input_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Input_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  result = (Fl_Fontsize)((Fl_Value_Input const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Input_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Input_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  result = (Fl_Color)((Fl_Value_Input const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Input_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Input_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Input_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_cursor_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  result = (Fl_Color)((Fl_Value_Input const *)arg1)->cursor_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_cursor_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Input_cursor_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Input * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->cursor_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Input_cursor_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Input_cursor_color__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Input_cursor_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_Value_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Input *arg1 = (Fl_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Value_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Value_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Flcc_HueBox_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Flcc_HueBox *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Flcc_HueBox_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Flcc_HueBox *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_HueBox_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Flcc_HueBox_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Flcc_HueBox * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Flcc_HueBox_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Flcc_HueBox::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flcc_HueBox(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Flcc_HueBox *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Flcc_HueBox",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Flcc_HueBox" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Flcc_HueBox" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Flcc_HueBox" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Flcc_HueBox" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  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); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Flcc_HueBox, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Flcc_HueBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Flcc_HueBox",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Flcc_HueBox * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Flcc_HueBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_HueBox *arg1 = (Flcc_HueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Flcc_HueBox",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Flcc_HueBox, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Flcc_ValueBox_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Flcc_ValueBox *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Flcc_ValueBox_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Flcc_ValueBox *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flcc_ValueBox_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Flcc_ValueBox_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Flcc_ValueBox * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Flcc_ValueBox_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Flcc_ValueBox::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flcc_ValueBox(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Flcc_ValueBox *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Flcc_ValueBox",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Flcc_ValueBox" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Flcc_ValueBox" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Flcc_ValueBox" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Flcc_ValueBox" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  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); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Flcc_ValueBox, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Flcc_ValueBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Flcc_ValueBox",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Flcc_ValueBox * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Flcc_ValueBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_ValueBox *arg1 = (Flcc_ValueBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Flcc_ValueBox",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Flcc_ValueBox, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Flcc_Value_Input_format(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Flcc_Value_Input_format",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Flcc_Value_Input * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Flcc_Value_Input::format(arg2);
    } else {
      result = (int)(arg1)->format(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flcc_Value_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Flcc_Value_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Flcc_Value_Input",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Flcc_Value_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Flcc_Value_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Flcc_Value_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Flcc_Value_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  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); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Flcc_Value_Input, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Flcc_Value_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Flcc_Value_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Flcc_Value_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Flcc_Value_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Flcc_Value_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Flcc_Value_Input *arg1 = (Flcc_Value_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Flcc_Value_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Flcc_Value_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Flcc_Value_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Flcc_Value_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_mode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_mode",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  result = (int)(arg1)->mode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_mode__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_mode",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->mode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_mode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Color_Chooser_mode__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Color_Chooser_mode__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_hue",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  result = (double)((Fl_Color_Chooser const *)arg1)->hue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_saturation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_saturation",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  result = (double)((Fl_Color_Chooser const *)arg1)->saturation();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  result = (double)((Fl_Color_Chooser const *)arg1)->value();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_r(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_r",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  result = (double)((Fl_Color_Chooser const *)arg1)->r();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_g",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  result = (double)((Fl_Color_Chooser const *)arg1)->g();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_b(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_b",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  result = (double)((Fl_Color_Chooser const *)arg1)->b();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_hsv(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_hsv",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_hsv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_hsv" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Color_Chooser_hsv" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (int)(arg1)->hsv(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_rgb(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_rgb",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_rgb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_rgb" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Color_Chooser_rgb" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (int)(arg1)->rgb(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_hsv2rgb(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_hsv2rgb",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &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_ValueError, "invalid null reference " "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &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_ValueError, "invalid null reference " "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &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_ValueError, "invalid null reference " "in method '" "Fl_Color_Chooser_hsv2rgb" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  Fl_Color_Chooser::hsv2rgb(arg1,arg2,arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Color_Chooser_rgb2hsv(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_rgb2hsv",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &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_ValueError, "invalid null reference " "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &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_ValueError, "invalid null reference " "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &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_ValueError, "invalid null reference " "in method '" "Fl_Color_Chooser_rgb2hsv" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  Fl_Color_Chooser::rgb2hsv(arg1,arg2,arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Color_Chooser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Color_Chooser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Color_Chooser",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Color_Chooser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Color_Chooser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Color_Chooser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Color_Chooser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Color_Chooser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Color_Chooser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Color_Chooser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Color_Chooser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Color_Chooser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color_Chooser *arg1 = (Fl_Color_Chooser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Color_Chooser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Color_Chooser_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Color_Chooser *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Color_Chooser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fl_color_chooser__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_color_chooser",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "fl_color_chooser" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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_ValueError, "invalid null reference " "in method '" "fl_color_chooser" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &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_ValueError, "invalid null reference " "in method '" "fl_color_chooser" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_color_chooser" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  result = (int)fl_color_chooser((char const *)arg1,*arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_chooser__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_color_chooser",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(obj1, &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_color_chooser" "', argument " "2"" of type '" "uchar""'");
    }
    temp2 = static_cast< uchar >(val);
    arg2 = &temp2;
    res2 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(obj2, &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_color_chooser" "', argument " "3"" of type '" "uchar""'");
    }
    temp3 = static_cast< uchar >(val);
    arg3 = &temp3;
    res3 = SWIG_AddTmpMask(ecode);
  }
  if (!(SWIG_IsOK((res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4),SWIGTYPE_p_unsigned_char,0))))) {
    unsigned char val;
    int ecode = SWIG_AsVal_unsigned_SS_char(obj3, &val);
    if (!SWIG_IsOK(ecode)) {
      SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "fl_color_chooser" "', argument " "4"" of type '" "uchar""'");
    }
    temp4 = static_cast< uchar >(val);
    arg4 = &temp4;
    res4 = SWIG_AddTmpMask(ecode);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_color_chooser" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  result = (int)fl_color_chooser((char const *)arg1,*arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
  } 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));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color_chooser(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 4) && (argc <= 5)) {
    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;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_fl_color_chooser__SWIG_0(self, args);
  }
check_1:
  
  if ((argc >= 4) && (argc <= 5)) {
    return _wrap_fl_color_chooser__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Counter *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Counter *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Counter::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Counter(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Counter *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Counter",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Counter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Counter" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Counter" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Counter" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Counter",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_lstep(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_lstep",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_lstep" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->lstep(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_step",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Counter_step" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->step(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_step",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->step(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_step",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  result = (double)((Fl_Counter const *)arg1)->step();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_step(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Counter_step__SWIG_2(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Counter_step__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Counter_step__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  result = (Fl_Font)((Fl_Counter const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Counter_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Counter_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  result = (Fl_Fontsize)((Fl_Counter const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Counter_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Counter_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  result = (Fl_Color)((Fl_Counter const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Counter_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Counter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Counter_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Counter_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Counter_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Counter_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_Counter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Counter *arg1 = (Fl_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Counter",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Counter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Dial_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Dial *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Dial_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Dial *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Dial_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Dial * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Dial::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Dial(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Dial *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Dial",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Dial" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Dial" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Dial" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Dial" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  short result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Dial_angle1",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Dial * >(argp1);
  result = (short)((Fl_Dial const *)arg1)->angle1();
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Dial_angle1",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Dial * >(argp1);
  ecode2 = SWIG_AsVal_short(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_angle1" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  (arg1)->angle1(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle1(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Dial_angle1__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Dial_angle1__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  short result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Dial_angle2",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Dial * >(argp1);
  result = (short)((Fl_Dial const *)arg1)->angle2();
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Dial_angle2",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Dial * >(argp1);
  ecode2 = SWIG_AsVal_short(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_angle2" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  (arg1)->angle2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Dial_angle2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Dial_angle2__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Dial_angle2__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Dial_angles",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Dial * >(argp1);
  ecode2 = SWIG_AsVal_short(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Dial_angles" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Dial_angles" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  (arg1)->angles(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Dial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Dial",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Dial * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Dial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Dial *arg1 = (Fl_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Dial",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Dial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Window_shape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_shape",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->shape((Fl_Image const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_shape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_shape",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Window_shape" "', argument " "2"" of type '" "Fl_Image const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->shape((Fl_Image const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_shape(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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_Window_shape__SWIG_0(self, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Window_shape__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Window_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Window *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_flush",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("flush"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member flush");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Window *>(arg1);
    if (upcall) {
      (darg)->flushSwigPublic();
    } else {
      (darg)->flush();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Window__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Window",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Window",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_new_Fl_Window__SWIG_0(self, args);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Window__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Window::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Window::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_border__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_border",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_border" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->border(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_clear_border(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_clear_border",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->clear_border();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_border__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_border",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (unsigned int)((Fl_Window const *)arg1)->border();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_border(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Window_border__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Window_border__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_set_override",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->set_override();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_override(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_override",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (unsigned int)((Fl_Window const *)arg1)->override();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_modal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_set_modal",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->set_modal();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_modal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_modal",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (unsigned int)((Fl_Window const *)arg1)->modal();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_non_modal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_set_non_modal",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->set_non_modal();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_non_modal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_non_modal",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (unsigned int)((Fl_Window const *)arg1)->non_modal();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_clear_modal_states(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_clear_modal_states",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->clear_modal_states();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_menu_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_set_menu_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->set_menu_window();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_menu_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_menu_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (unsigned int)((Fl_Window const *)arg1)->menu_window();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_set_tooltip_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_set_tooltip_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->set_tooltip_window();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_tooltip_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_tooltip_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (unsigned int)((Fl_Window const *)arg1)->tooltip_window();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hotspot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_hotspot",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_hotspot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_hotspot" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_hotspot" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  (arg1)->hotspot(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hotspot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_hotspot",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_hotspot" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  (arg1)->hotspot((Fl_Widget const *)arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hotspot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Window_hotspot__SWIG_1(self, args);
  }
check_1:
  
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_Fl_Window_hotspot__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_free_position",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->free_position();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_size_range(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_size_range",3,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_size_range" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_size_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_size_range" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_size_range" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Window_size_range" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Window_size_range" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Window_size_range" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< int >(val8);
  }
  (arg1)->size_range(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_label__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (char *)((Fl_Window const *)arg1)->label();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconlabel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_iconlabel",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (char *)((Fl_Window const *)arg1)->iconlabel();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_label__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconlabel__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_iconlabel",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->iconlabel((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconlabel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Window_iconlabel__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Window_iconlabel__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_label",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  (arg1)->label((char const *)arg2,(char const *)arg3);
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Window_label__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Window_label__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Window_label__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_copy_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->copy_label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_xclass__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_default_xclass",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_Window_default_xclass" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  Fl_Window::default_xclass((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_xclass__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_default_xclass",0,0)) SWIG_fail;
  result = (char *)Fl_Window::default_xclass();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_xclass(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Window_default_xclass__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Window_default_xclass__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_xclass",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (char *)((Fl_Window const *)arg1)->xclass();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_xclass__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_xclass",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->xclass((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_xclass(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Window_xclass__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Window_xclass__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image *arg1 = (Fl_RGB_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_default_icon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  Fl_Window::default_icon((Fl_RGB_Image const *)arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_icons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Image **arg1 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_default_icons",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image ** >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_default_icons" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  Fl_Window::default_icons((Fl_RGB_Image const *(*))arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_icon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_RGB_Image * >(argp2);
  (arg1)->icon((Fl_RGB_Image const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_RGB_Image **arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_icons",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_RGB_Image ** >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_icons" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->icons((Fl_RGB_Image const *(*))arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_icon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (void *)((Fl_Window const *)arg1)->icon();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_icon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 *""'"); 
  }
  (arg1)->icon((void const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_icon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Window_icon__SWIG_1(self, args);
  }
  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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Window_icon__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_shown",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Window * >(argp1);
  result = (int)(arg1)->shown();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Window::hide();
    } else {
      (arg1)->hide();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_wait_for_expose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_wait_for_expose",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->wait_for_expose();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_fullscreen",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->fullscreen();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_off__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_fullscreen_off",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->fullscreen_off();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_off__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_fullscreen_off",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_fullscreen_off" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_fullscreen_off" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_fullscreen_off" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_fullscreen_off" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->fullscreen_off(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_off(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Window_fullscreen_off__SWIG_0(self, args);
  }
  if (argc == 5) {
    return _wrap_Fl_Window_fullscreen_off__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_fullscreen_active",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (unsigned int)((Fl_Window const *)arg1)->fullscreen_active();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_fullscreen_screens(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_fullscreen_screens",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_fullscreen_screens" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_fullscreen_screens" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_fullscreen_screens" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Window_fullscreen_screens" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->fullscreen_screens(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_iconize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_iconize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->iconize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_x_root(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_x_root",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (int)((Fl_Window const *)arg1)->x_root();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_y_root(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_y_root",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  result = (int)((Fl_Window const *)arg1)->y_root();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_current(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_current",0,0)) SWIG_fail;
  result = (Fl_Window *)Fl_Window::current();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_make_current",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  (arg1)->make_current();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_as_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_as_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Window *)(arg1)->Fl_Window::as_window();
    } else {
      result = (Fl_Window *)(arg1)->as_window();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_cursor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Cursor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_cursor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = static_cast< Fl_Cursor >(val2);
  (arg1)->cursor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_cursor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_cursor",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_RGB_Image * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_cursor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_cursor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->cursor((Fl_RGB_Image const *)arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_cursor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  Fl_Cursor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_default_cursor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_default_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = static_cast< Fl_Cursor >(val2);
  (arg1)->default_cursor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_cursor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_cursor",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = static_cast< Fl_Cursor >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_cursor" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = static_cast< Fl_Color >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_cursor" "', argument " "4"" of type '" "Fl_Color""'");
    } 
    arg4 = static_cast< Fl_Color >(val4);
  }
  (arg1)->cursor(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_cursor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Window_cursor__SWIG_0(self, args);
  }
  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, args);
  }
check_2:
  
  if (argc == 4) {
    return _wrap_Fl_Window_cursor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_default_cursor",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Window_default_cursor" "', argument " "2"" of type '" "Fl_Cursor""'");
  } 
  arg2 = static_cast< Fl_Cursor >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Window_default_cursor" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = static_cast< Fl_Color >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Window_default_cursor" "', argument " "4"" of type '" "Fl_Color""'");
    } 
    arg4 = static_cast< Fl_Color >(val4);
  }
  (arg1)->default_cursor(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_default_cursor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Window_default_cursor__SWIG_0(self, args);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_Fl_Window_default_cursor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_default_callback",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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 *""'"); 
  }
  Fl_Window::default_callback(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_decorated_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_decorated_w",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Window * >(argp1);
  result = (int)(arg1)->decorated_w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_decorated_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_decorated_h",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Window * >(argp1);
  result = (int)(arg1)->decorated_h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Window_show(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Window_show",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Window * >(argp1);
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Window_show(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Window *arg1 = (Fl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Window, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Double_Window_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Double_Window_flush",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Double_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Double_Window::flush();
    } else {
      (arg1)->flush();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Double_Window_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Double_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Double_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Double_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Double_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Double_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Double_Window::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Double_Window_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Double_Window_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Double_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Double_Window::hide();
    } else {
      (arg1)->hide();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Double_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Double_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Double_Window * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Double_Window__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Double_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Double_Window",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Double_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Double_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Double_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Double_Window",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Double_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Double_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Double_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Double_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_new_Fl_Double_Window__SWIG_0(self, args);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Double_Window__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_show(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Double_Window_show",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Double_Window * >(argp1);
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Double_Window_show(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Double_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Double_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Double_Window *arg1 = (Fl_Double_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Double_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Double_Window_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Double_Window *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Double_Window, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fl_color__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  fl_color(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_color",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_color" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = static_cast< uchar >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_color" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_color" "', argument " "3"" of type '" "uchar""'");
  } 
  arg3 = static_cast< uchar >(val3);
  fl_color(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_color",0,0)) SWIG_fail;
  result = (Fl_Color)fl_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_fl_color__SWIG_2(self, args);
  }
  if (argc == 1) {
    return _wrap_fl_color__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_fl_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_push_clip",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_push_clip" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_push_clip" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_push_clip" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_push_clip" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_push_clip(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_push_no_clip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_push_no_clip",0,0)) SWIG_fail;
  fl_push_no_clip();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_pop_clip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_pop_clip",0,0)) SWIG_fail;
  fl_pop_clip();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_not_clipped(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_not_clipped",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_not_clipped" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_not_clipped" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_not_clipped" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_not_clipped" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)fl_not_clipped(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_clip_box(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  arg8 = &temp8;
  if(!PyArg_UnpackTuple(args,(char *)"fl_clip_box",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_clip_box" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_clip_box" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_clip_box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_clip_box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)fl_clip_box(arg1,arg2,arg3,arg4,*arg5,*arg6,*arg7,*arg8);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } 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));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } 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));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
  } 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));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_restore_clip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_restore_clip",0,0)) SWIG_fail;
  fl_restore_clip();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_clip_region__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Region arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_clip_region",1,1,&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &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_ValueError, "invalid null reference " "in method '" "fl_clip_region" "', argument " "1"" of type '" "Fl_Region""'");
    } else {
      Fl_Region * temp = reinterpret_cast< Fl_Region * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  fl_clip_region(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_clip_region__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Region result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_clip_region",0,0)) SWIG_fail;
  result = fl_clip_region();
  resultobj = SWIG_NewPointerObj((new Fl_Region(static_cast< const 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) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_fl_clip_region__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_fl_clip_region__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_point",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_point" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_point" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  fl_point(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_line_style(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_line_style",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_line_style" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_line_style" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  if (obj2) {
    res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_line_style" "', argument " "3"" of type '" "char *""'");
    }
    arg3 = reinterpret_cast< char * >(buf3);
  }
  fl_line_style(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rect__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rect",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_rect(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rect",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rect" "', argument " "5"" of type '" "Fl_Color""'");
  } 
  arg5 = static_cast< Fl_Color >(val5);
  fl_rect(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    return _wrap_fl_rect__SWIG_0(self, args);
  }
  if (argc == 5) {
    return _wrap_fl_rect__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(int,int,int,int,Fl_Color)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rectf",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_rectf(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rectf",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rectf" "', argument " "5"" of type '" "Fl_Color""'");
  } 
  arg5 = static_cast< Fl_Color >(val5);
  fl_rectf(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rectf",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_rectf" "', argument " "5"" of type '" "uchar""'");
  } 
  arg5 = static_cast< uchar >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_rectf" "', argument " "6"" of type '" "uchar""'");
  } 
  arg6 = static_cast< uchar >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_rectf" "', argument " "7"" of type '" "uchar""'");
  } 
  arg7 = static_cast< uchar >(val7);
  fl_rectf(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rectf(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    return _wrap_fl_rectf__SWIG_0(self, args);
  }
  if (argc == 5) {
    return _wrap_fl_rectf__SWIG_1(self, args);
  }
  if (argc == 7) {
    return _wrap_fl_rectf__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(int,int,int,int,uchar,uchar,uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_line__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_line",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_line" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_line" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_line" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_line" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_line(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_line__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_line",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_line" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_line" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_line" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_line" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_line" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_line" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  fl_line(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_line(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    return _wrap_fl_line__SWIG_0(self, args);
  }
  if (argc == 6) {
    return _wrap_fl_line__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_loop",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_loop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_loop" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  fl_loop(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_loop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_loop",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_loop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_loop" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_loop" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_loop" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  fl_loop(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_loop(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    return _wrap_fl_loop__SWIG_0(self, args);
  }
  if (argc == 8) {
    return _wrap_fl_loop__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_polygon",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_polygon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_polygon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_polygon" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_polygon" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_polygon" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_polygon" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  fl_polygon(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_polygon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_polygon",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_polygon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_polygon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_polygon" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_polygon" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_polygon" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_polygon" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_polygon" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_polygon" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  fl_polygon(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_polygon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[9];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    return _wrap_fl_polygon__SWIG_0(self, args);
  }
  if (argc == 8) {
    return _wrap_fl_polygon__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_xyline",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_xyline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_xyline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_xyline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  fl_xyline(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_xyline__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_xyline",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_xyline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_xyline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_xyline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_xyline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_xyline(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_xyline__SWIG_2(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_xyline",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_xyline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_xyline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_xyline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_xyline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_xyline" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  fl_xyline(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_xyline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_fl_xyline__SWIG_0(self, args);
  }
  if (argc == 4) {
    return _wrap_fl_xyline__SWIG_1(self, args);
  }
  if (argc == 5) {
    return _wrap_fl_xyline__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_yxline",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_yxline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_yxline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_yxline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  fl_yxline(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yxline__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_yxline",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_yxline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_yxline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_yxline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_yxline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_yxline(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yxline__SWIG_2(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_yxline",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_yxline" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_yxline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_yxline" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_yxline" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_yxline" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  fl_yxline(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_yxline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_fl_yxline__SWIG_0(self, args);
  }
  if (argc == 4) {
    return _wrap_fl_yxline__SWIG_1(self, args);
  }
  if (argc == 5) {
    return _wrap_fl_yxline__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_arc",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_arc" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_arc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_arc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_arc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_arc" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_arc" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  fl_arc(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_pie(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_pie",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_pie" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_pie" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_pie" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_pie" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_pie" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_pie" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  fl_pie(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_push_matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_push_matrix",0,0)) SWIG_fail;
  fl_push_matrix();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_pop_matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_pop_matrix",0,0)) SWIG_fail;
  fl_pop_matrix();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_scale",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  fl_scale(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_scale",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_scale" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  fl_scale(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scale(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_fl_scale__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_fl_scale__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_translate",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_translate" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_translate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  fl_translate(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rotate",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_rotate" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  fl_rotate(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mult_matrix(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mult_matrix",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_mult_matrix" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_mult_matrix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_mult_matrix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_mult_matrix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_mult_matrix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_mult_matrix" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  fl_mult_matrix(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_points(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_begin_points",0,0)) SWIG_fail;
  fl_begin_points();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_line(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_begin_line",0,0)) SWIG_fail;
  fl_begin_line();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_loop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_begin_loop",0,0)) SWIG_fail;
  fl_begin_loop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_polygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_begin_polygon",0,0)) SWIG_fail;
  fl_begin_polygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_vertex",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_vertex" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_vertex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  fl_vertex(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_curve(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_curve",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_curve" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_curve" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_curve" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_curve" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_curve" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_curve" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_curve" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_curve" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  fl_curve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_arc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_arc",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_arc" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_arc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_arc" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_arc" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_arc" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  fl_arc(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_arc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    return _wrap_fl_arc__SWIG_1(self, args);
  }
  if (argc == 6) {
    return _wrap_fl_arc__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_circle",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_circle" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_circle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_circle" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  fl_circle(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_points(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_end_points",0,0)) SWIG_fail;
  fl_end_points();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_line(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_end_line",0,0)) SWIG_fail;
  fl_end_line();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_loop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_end_loop",0,0)) SWIG_fail;
  fl_end_loop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_polygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_end_polygon",0,0)) SWIG_fail;
  fl_end_polygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_begin_complex_polygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_begin_complex_polygon",0,0)) SWIG_fail;
  fl_begin_complex_polygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_gap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_gap",0,0)) SWIG_fail;
  fl_gap();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_end_complex_polygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_end_complex_polygon",0,0)) SWIG_fail;
  fl_end_complex_polygon();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_transform_x",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_x" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_x" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)fl_transform_x(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_transform_y",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_y" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_y" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)fl_transform_y(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_dx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_transform_dx",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_dx" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_dx" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)fl_transform_dx(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transform_dy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_transform_dy",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transform_dy" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transform_dy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)fl_transform_dy(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_transformed_vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_transformed_vertex",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_transformed_vertex" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_transformed_vertex" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  fl_transformed_vertex(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_font__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  Fl_Fontsize arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_font",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_font" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  fl_font(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_font__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_font",0,0)) SWIG_fail;
  result = (Fl_Font)fl_font();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_font(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_fl_font__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_fl_font__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_size",0,0)) SWIG_fail;
  result = (Fl_Fontsize)fl_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_height__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_height",0,0)) SWIG_fail;
  result = (int)fl_height();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_height__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_height",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_height" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)fl_height(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_height(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_fl_height__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_fl_height__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_descent",0,0)) SWIG_fail;
  result = (int)fl_descent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_width",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_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (double)fl_width((char const *)arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_width",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_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)fl_width((char const *)arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_width",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_width" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (double)fl_width(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_width(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 1) {
    return _wrap_fl_width__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_fl_width__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  if(!PyArg_UnpackTuple(args,(char *)"fl_text_extents",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_text_extents" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_text_extents((char const *)arg1,*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_text_extents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if(!PyArg_UnpackTuple(args,(char *)"fl_text_extents",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_text_extents" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_text_extents" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  fl_text_extents((char const *)arg1,arg2,*arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } 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));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_text_extents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_fl_text_extents__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_fl_text_extents__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_latin1_to_local",1,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_latin1_to_local" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_latin1_to_local" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (char *)fl_latin1_to_local((char const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_local_to_latin1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_local_to_latin1",1,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_local_to_latin1" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_local_to_latin1" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (char *)fl_local_to_latin1((char const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mac_roman_to_local(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mac_roman_to_local",1,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_mac_roman_to_local" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_mac_roman_to_local" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (char *)fl_mac_roman_to_local((char const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_local_to_mac_roman(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_local_to_mac_roman",1,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_local_to_mac_roman" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_local_to_mac_roman" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (char *)fl_local_to_mac_roman((char const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  fl_draw((char const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_draw" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_draw(arg1,(char const *)arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_2(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw",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_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_draw((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_draw" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  fl_draw(arg1,(char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rtl_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rtl_draw",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_rtl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_rtl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_rtl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_rtl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_rtl_draw((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_measure(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"fl_measure",1,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_measure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode4 = SWIG_AsVal_int(obj1, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_measure" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  fl_measure((char const *)arg1,*arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw",6,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = static_cast< Fl_Align >(val6);
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &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 = reinterpret_cast< Fl_Image * >(argp7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_draw" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< int >(val8);
  }
  fl_draw((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw",7,9,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = static_cast< Fl_Align >(val6);
  {
    int res = SWIG_ConvertFunctionPtr(obj6, (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 (obj7) {
    res8 = SWIG_ConvertPtr(obj7, &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 = reinterpret_cast< Fl_Image * >(argp8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "fl_draw" "', argument " "9"" of type '" "int""'");
    } 
    arg9 = static_cast< int >(val9);
  }
  fl_draw((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[10];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_fl_draw__SWIG_0(self, args);
  }
  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;
    return _wrap_fl_draw__SWIG_1(self, args);
  }
check_2:
  
  if (argc == 4) {
    return _wrap_fl_draw__SWIG_2(self, args);
  }
  if (argc == 5) {
    return _wrap_fl_draw__SWIG_3(self, args);
  }
  if ((argc >= 6) && (argc <= 8)) {
    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;
      }
    }
    return _wrap_fl_draw__SWIG_4(self, args);
  }
check_5:
  
  if ((argc >= 7) && (argc <= 9)) {
    return _wrap_fl_draw__SWIG_5(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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)\n"
    "    fl_draw(char const *,int,int,int,int,Fl_Align,void (*)(char const *,int,int,int),Fl_Image *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fl_frame__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_frame",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_frame" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_frame" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_frame" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_frame" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_frame" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  fl_frame((char const *)arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_frame(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_fl_frame__SWIG_0(self, args);
  }
  if (argc == 5) {
    return _wrap_fl_frame__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_frame2",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_frame2" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_frame2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_frame2" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_frame2" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_frame2" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  fl_frame2((char const *)arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_box(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw_box",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_draw_box" "', argument " "1"" of type '" "Fl_Boxtype""'");
  } 
  arg1 = static_cast< Fl_Boxtype >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_box" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_box" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_box" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_box" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_box" "', argument " "6"" of type '" "Fl_Color""'");
  } 
  arg6 = static_cast< Fl_Color >(val6);
  fl_draw_box(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_image(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw_image",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  {
    /* Check if the input support the buffer protocol */
    Py_ssize_t size_buffer;
    const void * buffer;
    int failure = PyObject_AsReadBuffer(obj0,&buffer,&size_buffer);
    if (!failure) {
      // work with array object
      arg1 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_AsReadBuffer
      PyErr_Clear();
      size_buffer=0;
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(obj0)) {
        int size = PyList_Size(obj0);
        int i = 0;
        arg1 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(obj0,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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_image" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_image" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_draw_image" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  fl_draw_image((unsigned char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_image_mono(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw_image_mono",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  {
    /* Check if the input support the buffer protocol */
    Py_ssize_t size_buffer;
    const void * buffer;
    int failure = PyObject_AsReadBuffer(obj0,&buffer,&size_buffer);
    if (!failure) {
      // work with array object
      arg1 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_AsReadBuffer
      PyErr_Clear();
      size_buffer=0;
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(obj0)) {
        int size = PyList_Size(obj0);
        int i = 0;
        arg1 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(obj0,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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_image_mono" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_image_mono" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_image_mono" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_image_mono" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_image_mono" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_draw_image_mono" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  fl_draw_image_mono((unsigned char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_can_do_alpha_blending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_can_do_alpha_blending",0,0)) SWIG_fail;
  result = (char)fl_can_do_alpha_blending();
  resultobj = SWIG_NewPointerObj((new char(static_cast< const char& >(result))), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_pixmap(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw_pixmap",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    // Check if is a list
    if (PyList_Check(obj0)) {
      int size = PyList_Size(obj0);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj0,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        //arg1[i] = PyString_AsString(PyList_GetItem(obj0,i));
        arg1[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj0,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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_pixmap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_pixmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_pixmap" "', argument " "4"" of type '" "Fl_Color""'");
    } 
    arg4 = static_cast< Fl_Color >(val4);
  }
  result = (int)fl_draw_pixmap((char *const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    free((char *) arg1);
  }
  return resultobj;
fail:
  {
    free((char *) arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_measure_pixmap(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"fl_measure_pixmap",1,1,&obj0)) SWIG_fail;
  {
    // Check if is a list
    if (PyList_Check(obj0)) {
      int size = PyList_Size(obj0);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj0,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        //arg1[i] = PyString_AsString(PyList_GetItem(obj0,i));
        arg1[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj0,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;
    }
  }
  result = (int)fl_measure_pixmap((char *const *)arg1,*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  {
    free((char *) arg1);
  }
  return resultobj;
fail:
  {
    free((char *) arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_scroll(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_scroll",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_scroll" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_scroll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_scroll" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_scroll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_scroll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_scroll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  {
    int res = SWIG_ConvertFunctionPtr(obj6, (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(obj7,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 *""'"); 
  }
  fl_scroll(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_shortcut_label__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_shortcut_label",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_shortcut_label" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (char *)fl_shortcut_label(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_shortcut_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  char **arg2 = (char **) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_shortcut_label",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_shortcut_label" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    // Check if is a list
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
        arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  result = (char *)fl_shortcut_label(arg1,(char const **)arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_fl_shortcut_label__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_fl_shortcut_label__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_overlay_rect(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_overlay_rect",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_overlay_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_overlay_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_overlay_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_overlay_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_overlay_rect(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_overlay_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_overlay_clear",0,0)) SWIG_fail;
  fl_overlay_clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cursor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Cursor arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_cursor",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_cursor" "', argument " "1"" of type '" "Fl_Cursor""'");
  } 
  arg1 = static_cast< Fl_Cursor >(val1);
  fl_cursor(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cursor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_cursor",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_cursor" "', argument " "1"" of type '" "Fl_Cursor""'");
  } 
  arg1 = static_cast< Fl_Cursor >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_cursor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_cursor" "', argument " "3"" of type '" "Fl_Color""'");
    } 
    arg3 = static_cast< Fl_Color >(val3);
  }
  fl_cursor(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_cursor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_fl_cursor__SWIG_0(self, args);
  }
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_fl_cursor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char *result = 0 ;
  
  arg5 = &temp5;
  if(!PyArg_UnpackTuple(args,(char *)"fl_expand_text",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_expand_text" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_expand_text" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_expand_text" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  res6 = SWIG_ConvertPtr(obj4, &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_ValueError, "invalid null reference " "in method '" "fl_expand_text" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  ecode7 = SWIG_AsVal_int(obj5, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fl_expand_text" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  if (obj6) {
    ecode8 = SWIG_AsVal_int(obj6, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fl_expand_text" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< int >(val8);
  }
  result = (char *)fl_expand_text((char const *)arg1,arg2,arg3,arg4,*arg5,*arg6,arg7,arg8);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } 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));
  }
  {
    //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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_set_status",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_set_status" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_set_status" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_set_status" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_set_status" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  fl_set_status(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_set_spot(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_set_spot",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_set_spot" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_set_spot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_set_spot" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_set_spot" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_set_spot" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_set_spot" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &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 = reinterpret_cast< Fl_Window * >(argp7);
  }
  fl_set_spot(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_reset_spot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_reset_spot",0,0)) SWIG_fail;
  fl_reset_spot();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_draw_symbol(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_draw_symbol",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_draw_symbol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_draw_symbol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_draw_symbol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fl_draw_symbol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fl_draw_symbol" "', argument " "6"" of type '" "Fl_Color""'");
  } 
  arg6 = static_cast< Fl_Color >(val6);
  result = (int)fl_draw_symbol((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_add_symbol(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_add_symbol",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_add_symbol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)fl_add_symbol((char const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Input__resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Input__resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Input_::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Input_(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Input_ *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Input_",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Input_" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Input_" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Input_" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Input_" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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;
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Input_",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->value((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__value",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->value((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__static_value__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__static_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->static_value((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__static_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__static_value",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__static_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->static_value((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__static_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__static_value__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Input__static_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (char *)((Fl_Input_ const *)arg1)->value();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__value__SWIG_2(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__value__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Input__value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__index(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__index",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__index" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Fl_Char)((Fl_Input_ const *)arg1)->index(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__size",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->size(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__size__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Input__size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__maximum_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->maximum_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__maximum_size__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__maximum_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__maximum_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->maximum_size(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__maximum_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__maximum_size__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__maximum_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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__position__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__position",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__position" "', argument " "1"" of type '" "Fl_Input_ const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->position();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__mark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__mark",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->mark();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__position__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__position",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__position" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->position(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__position__SWIG_2(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__position",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Input_, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Input__position" "', argument " "1"" of type '" "Fl_Input_ *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->position(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__position(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__position__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__position__SWIG_2(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Input__position__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Input__position'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Input_::position() const\n"
    "    Fl_Input_::position(int,int)\n"
    "    Fl_Input_::position(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Input__mark__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__mark",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__mark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->mark(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__mark(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__mark__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__mark__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__replace",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__replace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Input__replace" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  result = (int)(arg1)->replace(arg2,arg3,(char const *)arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__cut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)(arg1)->cut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__cut",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__cut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->cut(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__cut",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__cut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__cut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->cut(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__cut__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__cut__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Input__cut__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__insert",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input__insert" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->insert((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__copy(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__copy",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->copy(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__undo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__undo",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)(arg1)->undo();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__copy_cuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__copy_cuts",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)(arg1)->copy_cuts();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__shortcut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->shortcut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__shortcut__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__shortcut",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->shortcut(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__shortcut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__shortcut__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__shortcut__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (Fl_Font)((Fl_Input_ const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (Fl_Fontsize)((Fl_Input_ const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (Fl_Color)((Fl_Input_ const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__cursor_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (Fl_Color)((Fl_Input_ const *)arg1)->cursor_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cursor_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__cursor_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__cursor_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->cursor_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__cursor_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__cursor_color__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__cursor_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__input_type",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->input_type();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__input_type__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__input_type",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__input_type" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->input_type(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__input_type(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__input_type__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__input_type__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__readonly",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->readonly();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__readonly__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__readonly",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__readonly" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->readonly(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__readonly(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__readonly__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__readonly__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__wrap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->wrap();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__wrap__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__wrap",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__wrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->wrap(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__wrap(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__wrap__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__wrap__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__tab_nav",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input__tab_nav" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->tab_nav(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__tab_nav__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input__tab_nav",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_ * >(argp1);
  result = (int)((Fl_Input_ const *)arg1)->tab_nav();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input__tab_nav(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input__tab_nav__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input__tab_nav__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_Input_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_ *arg1 = (Fl_Input_ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Input_",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Input_, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Input_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Input::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Input",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input *arg1 = (Fl_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_File_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_File_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_File_Input",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_File_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_File_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_File_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_File_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_File_Input::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_File_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_File_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_down_box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  result = (Fl_Boxtype)((Fl_File_Input const *)arg1)->down_box();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_down_box__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_down_box",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Boxtype >(val2);
  (arg1)->down_box(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_down_box(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Input_down_box__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Input_down_box__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_errorcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  result = (Fl_Color)((Fl_File_Input const *)arg1)->errorcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_errorcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_errorcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_File_Input_errorcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->errorcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_errorcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Input_errorcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Input_errorcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->value((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_value",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_File_Input_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->value((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_value__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_File_Input_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  result = (char *)(arg1)->value();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_File_Input_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_File_Input_value__SWIG_2(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_File_Input_value__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_File_Input_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_File_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_File_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_File_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_File_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_File_Input *arg1 = (Fl_File_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_File_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_File_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Fill_Dial(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Fill_Dial *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Fill_Dial",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Fill_Dial" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Fill_Dial" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Fill_Dial" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Fill_Dial" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  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); 
  }
  
  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_delete_Fl_Fill_Dial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Dial *arg1 = (Fl_Fill_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Fill_Dial",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Fill_Dial * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Fill_Dial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Dial *arg1 = (Fl_Fill_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Fill_Dial",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Dial *arg1 = (Fl_Fill_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Fill_Dial *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Fill_Dial_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Fill_Dial *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Fill_Dial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Slider_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Slider::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Slider__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Fl_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Slider",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Slider" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Slider" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_AsCharPtrAndSize(obj6, &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 = reinterpret_cast< char * >(buf7);
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Slider__SWIG_0(self, args);
  }
  if (argc == 7) {
    return _wrap_new_Fl_Slider__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_scrollvalue",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_scrollvalue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Slider_scrollvalue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Slider_scrollvalue" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Slider_scrollvalue" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (int)(arg1)->scrollvalue(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_bounds(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_bounds",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_bounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Slider_bounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bounds(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  float result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_slider_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  result = (float)((Fl_Slider const *)arg1)->slider_size();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_slider_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_slider_size" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->slider_size(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Slider_slider_size__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Slider_slider_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  result = (Fl_Boxtype)((Fl_Slider const *)arg1)->slider();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  Fl_Boxtype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Slider_slider",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Slider_slider" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  (arg1)->slider(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Slider_slider(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Slider_slider__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Slider_slider__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Slider *arg1 = (Fl_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Fill_Slider(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Fill_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Fill_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Fill_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Fill_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Fill_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Fill_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Fill_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Slider *arg1 = (Fl_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Fill_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Fill_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Fill_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Slider *arg1 = (Fl_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Fill_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fill_Slider *arg1 = (Fl_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Fill_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Fill_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Fill_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Fill_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Float_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Float_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Float_Input",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Float_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Float_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Float_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Float_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Float_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Float_Input *arg1 = (Fl_Float_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Float_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Float_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Float_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Float_Input *arg1 = (Fl_Float_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Float_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Float_Input *arg1 = (Fl_Float_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Float_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Float_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Float_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Float_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_FormsBitmap_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsBitmap *arg1 = (Fl_FormsBitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_FormsBitmap *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsBitmap_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsBitmap_draw" "', argument " "1"" of type '" "Fl_FormsBitmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsBitmap * >(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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_FormsBitmap *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_FormsBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Fl_FormsBitmap *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_FormsBitmap",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_FormsBitmap" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_FormsBitmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_FormsBitmap" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_FormsBitmap" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_FormsBitmap" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  if (obj6) {
    res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Fl_FormsBitmap" "', argument " "7"" of type '" "char const *""'");
    }
    arg7 = reinterpret_cast< char * >(buf7);
  }
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Fl_FormsBitmap *)new SwigDirector_Fl_FormsBitmap(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
  } else {
    result = (Fl_FormsBitmap *)new Fl_FormsBitmap(arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_FormsBitmap, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsBitmap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsBitmap *arg1 = (Fl_FormsBitmap *) 0 ;
  int arg2 ;
  int arg3 ;
  uchar *arg4 = (uchar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsBitmap_set",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsBitmap_set" "', argument " "1"" of type '" "Fl_FormsBitmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsBitmap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_FormsBitmap_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_FormsBitmap_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    /* Check if the input support the buffer protocol */
    Py_ssize_t size_buffer;
    const void * buffer;
    int failure = PyObject_AsReadBuffer(obj3,&buffer,&size_buffer);
    if (!failure) {
      // work with array object
      arg4 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_AsReadBuffer
      PyErr_Clear();
      size_buffer=0;
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(obj3)) {
        int size = PyList_Size(obj3);
        int i = 0;
        arg4 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(obj3,i);
          if (PyInt_Check(o))
          arg4[i] = (char)PyInt_AsLong(o);
          else {
            PyErr_SetString(PyExc_TypeError,"list must contain ints");
            free(arg4);
            return NULL;
          }
        }
        arg4[i] = 0;
      } else {
        PyErr_SetString(PyExc_TypeError,"not a list or does not support single-segment readable buffer interface");
        return NULL;
      }
    }
  }
  (arg1)->set(arg2,arg3,(uchar const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsBitmap_bitmap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsBitmap *arg1 = (Fl_FormsBitmap *) 0 ;
  Fl_Bitmap *arg2 = (Fl_Bitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsBitmap_bitmap",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsBitmap_bitmap" "', argument " "1"" of type '" "Fl_FormsBitmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsBitmap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_FormsBitmap_bitmap" "', argument " "2"" of type '" "Fl_Bitmap *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Bitmap * >(argp2);
  (arg1)->bitmap(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsBitmap_bitmap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsBitmap *arg1 = (Fl_FormsBitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Bitmap *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsBitmap_bitmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsBitmap_bitmap" "', argument " "1"" of type '" "Fl_FormsBitmap const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsBitmap * >(argp1);
  result = (Fl_Bitmap *)((Fl_FormsBitmap const *)arg1)->bitmap();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Bitmap, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsBitmap_bitmap(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_FormsBitmap_bitmap__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_FormsBitmap_bitmap__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_FormsBitmap_bitmap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_FormsBitmap::bitmap(Fl_Bitmap *)\n"
    "    Fl_FormsBitmap::bitmap() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_FormsBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsBitmap *arg1 = (Fl_FormsBitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_FormsBitmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsBitmap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_FormsBitmap" "', argument " "1"" of type '" "Fl_FormsBitmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsBitmap * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_FormsBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsBitmap *arg1 = (Fl_FormsBitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_FormsBitmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_FormsBitmap" "', argument " "1"" of type '" "Fl_FormsBitmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsBitmap * >(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_FormsBitmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_FormsBitmap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_FormsPixmap_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsPixmap *arg1 = (Fl_FormsPixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_FormsPixmap *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsPixmap_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsPixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsPixmap_draw" "', argument " "1"" of type '" "Fl_FormsPixmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsPixmap * >(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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_FormsPixmap *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_FormsPixmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Fl_FormsPixmap *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_FormsPixmap",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_FormsPixmap" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_FormsPixmap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_FormsPixmap" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_FormsPixmap" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_FormsPixmap" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  if (obj6) {
    res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Fl_FormsPixmap" "', argument " "7"" of type '" "char const *""'");
    }
    arg7 = reinterpret_cast< char * >(buf7);
  }
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Fl_FormsPixmap *)new SwigDirector_Fl_FormsPixmap(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
  } else {
    result = (Fl_FormsPixmap *)new Fl_FormsPixmap(arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_FormsPixmap, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsPixmap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsPixmap *arg1 = (Fl_FormsPixmap *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsPixmap_set",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsPixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsPixmap_set" "', argument " "1"" of type '" "Fl_FormsPixmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsPixmap * >(argp1);
  {
    // Check if is a list
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
        arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  (arg1)->set((char *const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    free((char *) arg2);
  }
  return resultobj;
fail:
  {
    free((char *) arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsPixmap_Pixmap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsPixmap *arg1 = (Fl_FormsPixmap *) 0 ;
  Fl_Pixmap *arg2 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsPixmap_Pixmap",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsPixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsPixmap_Pixmap" "', argument " "1"" of type '" "Fl_FormsPixmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsPixmap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_FormsPixmap_Pixmap" "', argument " "2"" of type '" "Fl_Pixmap *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Pixmap * >(argp2);
  (arg1)->Pixmap(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsPixmap_Pixmap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsPixmap *arg1 = (Fl_FormsPixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Pixmap *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_FormsPixmap_Pixmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsPixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_FormsPixmap_Pixmap" "', argument " "1"" of type '" "Fl_FormsPixmap const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsPixmap * >(argp1);
  result = (Fl_Pixmap *)((Fl_FormsPixmap const *)arg1)->Pixmap();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Pixmap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_FormsPixmap_Pixmap(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_FormsPixmap_Pixmap__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_FormsPixmap_Pixmap__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_FormsPixmap_Pixmap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_FormsPixmap::Pixmap(Fl_Pixmap *)\n"
    "    Fl_FormsPixmap::Pixmap() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_FormsPixmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsPixmap *arg1 = (Fl_FormsPixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_FormsPixmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsPixmap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_FormsPixmap" "', argument " "1"" of type '" "Fl_FormsPixmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsPixmap * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_FormsPixmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_FormsPixmap *arg1 = (Fl_FormsPixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_FormsPixmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_FormsPixmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_FormsPixmap" "', argument " "1"" of type '" "Fl_FormsPixmap *""'"); 
  }
  arg1 = reinterpret_cast< Fl_FormsPixmap * >(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_FormsPixmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_FormsPixmap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Free_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Free *arg1 = (Fl_Free *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Free *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Free_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Free, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Free_draw" "', argument " "1"" of type '" "Fl_Free *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Free * >(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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Free *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Free_handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Free *arg1 = (Fl_Free *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Free_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Free, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Free_handle" "', argument " "1"" of type '" "Fl_Free *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Free * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Free_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Free::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  uchar arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  char *arg7 = (char *) 0 ;
  FL_HANDLEPTR arg8 = (FL_HANDLEPTR) 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Fl_Free *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Free",8,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Free" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Free" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Free" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Free" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Free" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Fl_Free" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = reinterpret_cast< char * >(buf7);
  {
    int res = SWIG_ConvertFunctionPtr(obj7, (void**)(&arg8), SWIGTYPE_p_f_p_Fl_Widget_int_float_float_char__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_Fl_Free" "', argument " "8"" of type '" "FL_HANDLEPTR""'"); 
    }
  }
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Fl_Free *)new SwigDirector_Fl_Free(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7,arg8); 
  } else {
    result = (Fl_Free *)new Fl_Free(arg2,arg3,arg4,arg5,arg6,(char const *)arg7,arg8); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Free, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Free *arg1 = (Fl_Free *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Free",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Free, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Free" "', argument " "1"" of type '" "Fl_Free *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Free * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Free *arg1 = (Fl_Free *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Free",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Free, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Free" "', argument " "1"" of type '" "Fl_Free *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Free * >(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_Free_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Free, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Pixmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char **arg2 = (char **) 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Pixmap *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Pixmap",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  {
    /* Check if it is a list */
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
          arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Pixmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_copy",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Pixmap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Image *)(arg1)->Fl_Pixmap::copy(arg2,arg3);
    } else {
      result = (Fl_Image *)(arg1)->copy(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_copy",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Pixmap * >(argp1);
  result = (Fl_Image *)(arg1)->copy();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Pixmap_copy__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Pixmap_copy__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Pixmap_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Pixmap::copy(int,int)\n"
    "    Fl_Pixmap::copy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_color_average(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_color_average",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_color_average" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Pixmap::color_average(arg2,arg3);
    } else {
      (arg1)->color_average(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_desaturate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_desaturate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Pixmap::desaturate();
    } else {
      (arg1)->desaturate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_draw",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Pixmap_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Pixmap_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Pixmap_draw" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Pixmap_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pixmap_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Pixmap_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->draw(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_Pixmap_draw__SWIG_1(self, args);
  }
  if ((argc >= 5) && (argc <= 7)) {
    return _wrap_Fl_Pixmap_draw__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Pixmap::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Pixmap::label(arg2);
    } else {
      (arg1)->label(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pixmap_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Pixmap_label__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pixmap_uncache",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pixmap * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Pixmap::uncache();
    } else {
      (arg1)->uncache();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Pixmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pixmap *arg1 = (Fl_Pixmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Pixmap",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Pixmap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_GIF_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_GIF_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_GIF_Image",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  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); 
  }
  
  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_delete_Fl_GIF_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_GIF_Image *arg1 = (Fl_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_GIF_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_GIF_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_GIF_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_GIF_Image *arg1 = (Fl_GIF_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_GIF_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_GIF_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Gl_Window_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_flush",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Gl_Window::flush();
    } else {
      (arg1)->flush();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Gl_Window::hide();
    } else {
      (arg1)->hide();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Gl_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Gl_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Gl_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Gl_Window::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Gl_Window::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_valid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_valid",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (char)((Fl_Gl_Window const *)arg1)->valid();
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_valid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_valid",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_valid" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->valid(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_valid(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Gl_Window_valid__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Gl_Window_valid__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_invalidate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  (arg1)->invalidate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context_valid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_context_valid",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (char)((Fl_Gl_Window const *)arg1)->context_valid();
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context_valid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_context_valid",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_context_valid" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->context_valid(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context_valid(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Gl_Window_context_valid__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Gl_Window_context_valid__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_can_do",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Gl_Window_can_do" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (int)Fl_Gl_Window::can_do(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_can_do",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< int * >(argp1);
  result = (int)Fl_Gl_Window::can_do((int const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_can_do",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (int)(arg1)->can_do();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
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, args);
  }
check_2:
  
  if (argc == 1) {
    return _wrap_Fl_Gl_Window_can_do__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Mode result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_mode",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (Fl_Mode)((Fl_Gl_Window const *)arg1)->mode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_mode__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_mode",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Gl_Window_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->mode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_mode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_mode",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  result = (int)(arg1)->mode((int const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_mode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Gl_Window_mode__SWIG_0(self, args);
  }
  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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Gl_Window_mode__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_context",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (void *)((Fl_Gl_Window const *)arg1)->context();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 = (int) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_context",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Gl_Window_context" "', argument " "2"" of type '" "void *""'"); 
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Gl_Window_context" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  (arg1)->context(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_context(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Gl_Window_context__SWIG_0(self, args);
  }
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_Fl_Gl_Window_context__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(void *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_make_current(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_make_current",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  (arg1)->make_current();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_swap_buffers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_swap_buffers",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  (arg1)->swap_buffers();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_ortho(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_ortho",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  (arg1)->ortho();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_can_do_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_can_do_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (int)(arg1)->can_do_overlay();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_redraw_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_redraw_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  (arg1)->redraw_overlay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_hide_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_hide_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  (arg1)->hide_overlay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_make_overlay_current(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_make_overlay_current",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  (arg1)->make_overlay_current();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_as_gl_window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Gl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_as_gl_window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_pixels_per_unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  float result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_pixels_per_unit",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (float)(arg1)->pixels_per_unit();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_pixel_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_pixel_w",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (int)(arg1)->pixel_w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_pixel_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_pixel_h",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  result = (int)(arg1)->pixel_h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Gl_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Gl_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Gl_Window__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Gl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Gl_Window",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Gl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Gl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Gl_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Gl_Window",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Gl_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Gl_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Gl_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Gl_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_new_Fl_Gl_Window__SWIG_0(self, args);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Gl_Window__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Gl_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Gl_Window *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_show(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_show",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Gl_Window_show(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Gl_Window_drawPixels(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Gl_Window_drawPixels",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Gl_Window * >(argp1);
  arg2 = obj1;
  Fl_Gl_Window_drawPixels(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Gl_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Gl_Window *arg1 = (Fl_Gl_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Gl_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Gl_Window, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_gl_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_start",0,0)) SWIG_fail;
  gl_start();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_finish(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_finish",0,0)) SWIG_fail;
  gl_finish();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_color__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  gl_color(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_color" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  gl_color(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 1) {
    return _wrap_gl_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_rect",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_rect" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_rect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_rect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_rect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  gl_rect(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_rectf(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_rectf",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_rectf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_rectf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_rectf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_rectf" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  gl_rectf(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_font",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_font" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_font" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  gl_font(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_height",0,0)) SWIG_fail;
  result = (int)gl_height();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_descent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_descent",0,0)) SWIG_fail;
  result = (int)gl_descent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (double)gl_width((char const *)arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_width",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 '" "gl_width" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)gl_width((char const *)arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  uchar arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_width",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gl_width" "', argument " "1"" of type '" "uchar""'");
  } 
  arg1 = static_cast< uchar >(val1);
  result = (double)gl_width(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_width(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 1) {
    return _wrap_gl_width__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_gl_width__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  gl_draw((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw",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 '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  gl_draw((char const *)arg1,arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  gl_draw((char const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  gl_draw((char const *)arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_4(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw",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 '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  gl_draw((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw",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 '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  gl_draw((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_draw" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gl_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gl_draw" "', argument " "6"" of type '" "Fl_Align""'");
  } 
  arg6 = static_cast< Fl_Align >(val6);
  gl_draw((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_gl_draw__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_gl_draw__SWIG_1(self, args);
  }
  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, args);
  }
check_3:
  
  if (argc == 3) {
    return _wrap_gl_draw__SWIG_3(self, args);
  }
  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, args);
  }
check_5:
  
  if (argc == 4) {
    return _wrap_gl_draw__SWIG_5(self, args);
  }
  if (argc == 6) {
    return _wrap_gl_draw__SWIG_6(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"gl_measure",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl_measure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  gl_measure((char const *)arg1,*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gl_draw_image(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"gl_draw_image",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  {
    /* Check if the input support the buffer protocol */
    Py_ssize_t size_buffer;
    const void * buffer;
    int failure = PyObject_AsReadBuffer(obj0,&buffer,&size_buffer);
    if (!failure) {
      // work with array object
      arg1 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_AsReadBuffer
      PyErr_Clear();
      size_buffer=0;
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(obj0)) {
        int size = PyList_Size(obj0);
        int i = 0;
        arg1 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(obj0,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(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gl_draw_image" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gl_draw_image" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gl_draw_image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gl_draw_image" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gl_draw_image" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gl_draw_image" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  gl_draw_image((unsigned char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Help_Dialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_Dialog",0,0)) SWIG_fail;
  result = (Fl_Help_Dialog *)new Fl_Help_Dialog();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Help_Dialog",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_h",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  result = (int)(arg1)->h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  (arg1)->hide();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_load(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_load",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->load((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_position(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_position",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_Dialog_position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->position(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_Dialog_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Help_Dialog_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Help_Dialog_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->resize(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_show__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_show",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  (arg1)->show();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_show__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_show",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_show" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    /* Check if it is a list */
    if (PyList_Check(obj2)) {
      int size = PyList_Size(obj2);
      int i = 0;
      arg3 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj2,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg3[i] = PyString_AsString(PyList_GetItem(obj2,i));
          arg3[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj2,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;
    }
  }
  (arg1)->show(arg2,arg3);
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_Dialog_show__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Help_Dialog_show__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  result = (Fl_Fontsize)(arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_Dialog_textsize__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_Dialog_textsize__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_topline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->topline((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_topline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_topline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Dialog_topline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->topline(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_topline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Help_Dialog_topline__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->value((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  result = (char *)((Fl_Help_Dialog const *)arg1)->value();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_Dialog_value__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_Dialog_value__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  result = (int)(arg1)->visible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_w",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  result = (int)(arg1)->w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_x",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  result = (int)(arg1)->x();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Dialog_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Dialog *arg1 = (Fl_Help_Dialog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Dialog_y",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_Dialog * >(argp1);
  result = (int)(arg1)->y();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Help_Dialog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Help_Dialog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Help_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Block *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_Block",0,0)) SWIG_fail;
  result = (Fl_Help_Block *)new Fl_Help_Block();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_Block, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Help_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Block *arg1 = (Fl_Help_Block *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Help_Block",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Block, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Help_Block" "', argument " "1"" of type '" "Fl_Help_Block *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Block * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Help_Block_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Help_Block, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Help_Link(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Link *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_Link",0,0)) SWIG_fail;
  result = (Fl_Help_Link *)new Fl_Help_Link();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_Link, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Help_Link(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Link *arg1 = (Fl_Help_Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Help_Link",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Link, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Help_Link" "', argument " "1"" of type '" "Fl_Help_Link *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Link * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Help_Link_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Help_Link, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Help_Font_Style_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Style *arg1 = (Fl_Help_Font_Style *) 0 ;
  Fl_Font *arg2 = 0 ;
  Fl_Fontsize *arg3 = 0 ;
  Fl_Color *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font temp2 ;
  int res2 = SWIG_TMPOBJ ;
  Fl_Fontsize temp3 ;
  int res3 = SWIG_TMPOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Font_Style_get",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Style, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Font_Style_get" "', argument " "1"" of type '" "Fl_Help_Font_Style *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Style * >(argp1);
  res4 = SWIG_ConvertPtr(obj1, &argp4, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Help_Font_Style_get" "', argument " "4"" of type '" "Fl_Color &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Help_Font_Style_get" "', argument " "4"" of type '" "Fl_Color &""'"); 
  }
  arg4 = reinterpret_cast< Fl_Color * >(argp4);
  (arg1)->get(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Font_Style_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Style *arg1 = (Fl_Help_Font_Style *) 0 ;
  Fl_Font arg2 ;
  Fl_Fontsize arg3 ;
  Fl_Color arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Font_Style_set",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Style, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Font_Style_set" "', argument " "1"" of type '" "Fl_Help_Font_Style *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Style * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Font_Style_set" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_Font_Style_set" "', argument " "3"" of type '" "Fl_Fontsize""'");
  } 
  arg3 = static_cast< Fl_Fontsize >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Help_Font_Style_set" "', argument " "4"" of type '" "Fl_Color""'");
  } 
  arg4 = static_cast< Fl_Color >(val4);
  (arg1)->set(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Help_Font_Style__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  Fl_Fontsize arg2 ;
  Fl_Color arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Help_Font_Style *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_Font_Style",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Help_Font_Style" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Help_Font_Style" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Help_Font_Style" "', argument " "3"" of type '" "Fl_Color""'");
  } 
  arg3 = static_cast< Fl_Color >(val3);
  result = (Fl_Help_Font_Style *)new Fl_Help_Font_Style(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_Font_Style, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Help_Font_Style__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Style *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_Font_Style",0,0)) SWIG_fail;
  result = (Fl_Help_Font_Style *)new Fl_Help_Font_Style();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_Font_Style, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Help_Font_Style(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Fl_Help_Font_Style__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_new_Fl_Help_Font_Style__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Fl_Help_Font_Style'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_Font_Style::Fl_Help_Font_Style(Fl_Font,Fl_Fontsize,Fl_Color)\n"
    "    Fl_Help_Font_Style::Fl_Help_Font_Style()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Help_Font_Style(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Style *arg1 = (Fl_Help_Font_Style *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Help_Font_Style",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Style, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Help_Font_Style" "', argument " "1"" of type '" "Fl_Help_Font_Style *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Style * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Help_Font_Style_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Help_Font_Style, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Help_Font_Stack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Stack *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_Font_Stack",0,0)) SWIG_fail;
  result = (Fl_Help_Font_Stack *)new Fl_Help_Font_Stack();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_Font_Stack, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Font_Stack_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Stack *arg1 = (Fl_Help_Font_Stack *) 0 ;
  Fl_Font arg2 ;
  Fl_Fontsize arg3 ;
  Fl_Color arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Font_Stack_init",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Stack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Font_Stack_init" "', argument " "1"" of type '" "Fl_Help_Font_Stack *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Stack * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Font_Stack_init" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_Font_Stack_init" "', argument " "3"" of type '" "Fl_Fontsize""'");
  } 
  arg3 = static_cast< Fl_Fontsize >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Help_Font_Stack_init" "', argument " "4"" of type '" "Fl_Color""'");
  } 
  arg4 = static_cast< Fl_Color >(val4);
  (arg1)->init(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Font_Stack_top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Stack *arg1 = (Fl_Help_Font_Stack *) 0 ;
  Fl_Font *arg2 = 0 ;
  Fl_Fontsize *arg3 = 0 ;
  Fl_Color *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font temp2 ;
  int res2 = SWIG_TMPOBJ ;
  Fl_Fontsize temp3 ;
  int res3 = SWIG_TMPOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Font_Stack_top",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Stack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Font_Stack_top" "', argument " "1"" of type '" "Fl_Help_Font_Stack *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Stack * >(argp1);
  res4 = SWIG_ConvertPtr(obj1, &argp4, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Help_Font_Stack_top" "', argument " "4"" of type '" "Fl_Color &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Help_Font_Stack_top" "', argument " "4"" of type '" "Fl_Color &""'"); 
  }
  arg4 = reinterpret_cast< Fl_Color * >(argp4);
  (arg1)->top(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Font_Stack_push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Stack *arg1 = (Fl_Help_Font_Stack *) 0 ;
  Fl_Font arg2 ;
  Fl_Fontsize arg3 ;
  Fl_Color arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Font_Stack_push",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Stack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Font_Stack_push" "', argument " "1"" of type '" "Fl_Help_Font_Stack *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Stack * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_Font_Stack_push" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_Font_Stack_push" "', argument " "3"" of type '" "Fl_Fontsize""'");
  } 
  arg3 = static_cast< Fl_Fontsize >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Help_Font_Stack_push" "', argument " "4"" of type '" "Fl_Color""'");
  } 
  arg4 = static_cast< Fl_Color >(val4);
  (arg1)->push(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Font_Stack_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Stack *arg1 = (Fl_Help_Font_Stack *) 0 ;
  Fl_Font *arg2 = 0 ;
  Fl_Fontsize *arg3 = 0 ;
  Fl_Color *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Fl_Font temp2 ;
  int res2 = SWIG_TMPOBJ ;
  Fl_Fontsize temp3 ;
  int res3 = SWIG_TMPOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Font_Stack_pop",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Stack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Font_Stack_pop" "', argument " "1"" of type '" "Fl_Help_Font_Stack *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Stack * >(argp1);
  res4 = SWIG_ConvertPtr(obj1, &argp4, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Help_Font_Stack_pop" "', argument " "4"" of type '" "Fl_Color &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Help_Font_Stack_pop" "', argument " "4"" of type '" "Fl_Color &""'"); 
  }
  arg4 = reinterpret_cast< Fl_Color * >(argp4);
  (arg1)->pop(*arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_Font_Stack_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Stack *arg1 = (Fl_Help_Font_Stack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  size_t result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_Font_Stack_count",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Stack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Help_Font_Stack_count" "', argument " "1"" of type '" "Fl_Help_Font_Stack const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Stack * >(argp1);
  result = ((Fl_Help_Font_Stack const *)arg1)->count();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Help_Font_Stack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Font_Stack *arg1 = (Fl_Help_Font_Stack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Help_Font_Stack",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Font_Stack, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Help_Font_Stack" "', argument " "1"" of type '" "Fl_Help_Font_Stack *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Font_Stack * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Help_Font_Stack_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Help_Font_Stack, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Help_Target(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Target *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_Target",0,0)) SWIG_fail;
  result = (Fl_Help_Target *)new Fl_Help_Target();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Help_Target, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Help_Target(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_Target *arg1 = (Fl_Help_Target *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Help_Target",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Help_Target, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Help_Target" "', argument " "1"" of type '" "Fl_Help_Target *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_Target * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Help_Target_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Help_Target, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Help_View(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Help_View *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Help_View",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Help_View" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Help_View" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Help_View" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Help_View" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Help_View",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_directory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_directory",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (char *)((Fl_Help_View const *)arg1)->directory();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_filename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_filename",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (char *)((Fl_Help_View const *)arg1)->filename();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_find(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_find",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_View_find" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->find((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_link__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_link",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 *""'"); 
    }
  }
  (arg1)->link(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_load(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_load",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->load((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_View_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Help_View_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Help_View_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Help_View::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (int)((Fl_Help_View const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_size",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Help_View_size" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->size(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_size__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Help_View_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Help_View_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Help_View::size() const\n"
    "    Fl_Help_View::size(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textcolor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (Fl_Color)((Fl_Help_View const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_textcolor__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_View_textcolor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (Fl_Font)((Fl_Help_View const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_textfont__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_View_textfont__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (Fl_Fontsize)((Fl_Help_View const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_textsize__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_View_textsize__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_title(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_title",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (char *)(arg1)->title();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_topline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->topline((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_topline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_topline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->topline(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_topline",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (int)((Fl_Help_View const *)arg1)->topline();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_topline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_topline__SWIG_2(self, args);
  }
  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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Help_View_topline__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_leftline",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_leftline" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->leftline(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_leftline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_leftline",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (int)((Fl_Help_View const *)arg1)->leftline();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_leftline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_leftline__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_View_leftline__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_value__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->value((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (char *)((Fl_Help_View const *)arg1)->value();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_value__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_View_value__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_clear_selection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_clear_selection",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  (arg1)->clear_selection();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_select_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_select_all",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  (arg1)->select_all();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_scrollbar_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_scrollbar_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  result = (int)((Fl_Help_View const *)arg1)->scrollbar_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_scrollbar_size__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_scrollbar_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Help_View_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->scrollbar_size(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_scrollbar_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Help_View_scrollbar_size__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_View_scrollbar_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_link__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_link",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Help_View * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  arg3 = obj2;
  Fl_Help_View_link__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Help_View_link(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Help_View_link__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Help_View_link__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Help_View",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *_wrap_Fl_Help_View_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Help_View *arg1 = (Fl_Help_View *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Help_View *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Help_View_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Help_View *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Help_View_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Help_View, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Hold_Browser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Hold_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Hold_Browser",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hold_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hold_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hold_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hold_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Hold_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Hold_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hold_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Hold_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_prev",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_width(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_quick_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_quick_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Hold_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    if (upcall) {
      (darg)->item_swapSwigPublic(arg2,arg3);
    } else {
      (darg)->item_swap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_at",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Hold_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_full_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_full_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_full_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_incr_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hold_Browser *arg1 = (Fl_Hold_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_incr_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_select",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Hold_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    if (upcall) {
      (darg)->item_selectSwigPublic(arg2,arg3);
    } else {
      (darg)->item_select(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Hold_Browser_item_selected(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hold_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hold_Browser_item_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hold_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hold_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Hold_Browser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Hold_Browser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Fill_Slider(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Hor_Fill_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Hor_Fill_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Fill_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Hor_Fill_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Fill_Slider *arg1 = (Fl_Hor_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Hor_Fill_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hor_Fill_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Fill_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Fill_Slider *arg1 = (Fl_Hor_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Hor_Fill_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Fill_Slider *arg1 = (Fl_Hor_Fill_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Fill_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hor_Fill_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Fill_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Hor_Fill_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Nice_Slider(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Hor_Nice_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Hor_Nice_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Nice_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Hor_Nice_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Nice_Slider *arg1 = (Fl_Hor_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Hor_Nice_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hor_Nice_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Nice_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Nice_Slider *arg1 = (Fl_Hor_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Hor_Nice_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Nice_Slider *arg1 = (Fl_Hor_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Nice_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hor_Nice_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Nice_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Hor_Nice_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Slider(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Hor_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Hor_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Hor_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Slider *arg1 = (Fl_Hor_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Hor_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hor_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Slider *arg1 = (Fl_Hor_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Hor_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Slider *arg1 = (Fl_Hor_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hor_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Hor_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Value_Slider_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Value_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Value_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Value_Slider::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Value_Slider(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Value_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Value_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Value_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Value_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Value_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Value_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  result = (Fl_Font)((Fl_Value_Slider const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Slider_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Slider_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  result = (Fl_Fontsize)((Fl_Value_Slider const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Slider_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Slider_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  result = (Fl_Color)((Fl_Value_Slider const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Slider_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Slider_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Slider_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Slider_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Slider_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Value_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Value_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Value_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Slider *arg1 = (Fl_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Value_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Value_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Hor_Value_Slider(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Hor_Value_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Hor_Value_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Hor_Value_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Hor_Value_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Value_Slider *arg1 = (Fl_Hor_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Hor_Value_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Hor_Value_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Hor_Value_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Value_Slider *arg1 = (Fl_Hor_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Hor_Value_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Hor_Value_Slider *arg1 = (Fl_Hor_Value_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Hor_Value_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Hor_Value_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Hor_Value_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Hor_Value_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Int_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Int_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Int_Input",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Int_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Int_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Int_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Int_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Int_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Int_Input *arg1 = (Fl_Int_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Int_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Int_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Int_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Int_Input *arg1 = (Fl_Int_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Int_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Int_Input *arg1 = (Fl_Int_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Int_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Int_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Int_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Int_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Input_Choice(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Input_Choice *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Input_Choice",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Input_Choice" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Input_Choice" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Input_Choice" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Input_Choice" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_add(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->add((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_changed",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (int)((Fl_Input_Choice const *)arg1)->changed();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_clear_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_clear_changed",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  (arg1)->clear_changed();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_set_changed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_set_changed",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  (arg1)->set_changed();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_down_box__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_down_box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (Fl_Boxtype)((Fl_Input_Choice const *)arg1)->down_box();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_down_box__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_down_box",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Boxtype >(val2);
  (arg1)->down_box(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_down_box(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input_Choice_down_box__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input_Choice_down_box__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_menu",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (Fl_Menu_Item *)(arg1)->menu();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_menu",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  (arg1)->menu((Fl_Menu_Item const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_menu(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input_Choice_menu__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input_Choice_menu__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Input_Choice_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Input_Choice_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Input_Choice_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Input_Choice::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textcolor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (Fl_Color)((Fl_Input_Choice const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input_Choice_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input_Choice_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (Fl_Font)((Fl_Input_Choice const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input_Choice_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input_Choice_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (Fl_Fontsize)((Fl_Input_Choice const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input_Choice_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Input_Choice_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (char *)((Fl_Input_Choice const *)arg1)->value();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_value__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->value((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_value__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Input_Choice_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Input_Choice_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Input_Choice_value__SWIG_0(self, args);
  }
  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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Input_Choice_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_menubutton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_menubutton",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (Fl_Menu_Button *)(arg1)->menubutton();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  result = (Fl_Input *)(arg1)->input();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_delete_Fl_Input_Choice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Input_Choice",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Input_Choice * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Input_Choice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Input_Choice",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *_wrap_Fl_Input_Choice_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Input_Choice *arg1 = (Fl_Input_Choice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Input_Choice *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Input_Choice_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Input_Choice *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Input_Choice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Input_Choice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_JPEG_Image__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_JPEG_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_JPEG_Image",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_JPEG_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_JPEG_Image",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fl_JPEG_Image" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Fl_JPEG_Image *)new SwigDirector_Fl_JPEG_Image(arg1,(char const *)arg2,(unsigned char const *)arg3); 
  } else {
    result = (Fl_JPEG_Image *)new Fl_JPEG_Image((char const *)arg2,(unsigned char const *)arg3); 
  }
  
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_new_Fl_JPEG_Image__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_new_Fl_JPEG_Image__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_JPEG_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_JPEG_Image *arg1 = (Fl_JPEG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_JPEG_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_JPEG_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_JPEG_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_JPEG_Image *arg1 = (Fl_JPEG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_JPEG_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_JPEG_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Line_Dial(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Line_Dial *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Line_Dial",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Line_Dial" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Line_Dial" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Line_Dial" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Line_Dial" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Line_Dial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Line_Dial *arg1 = (Fl_Line_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Line_Dial",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Line_Dial * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Line_Dial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Line_Dial *arg1 = (Fl_Line_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Line_Dial",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Line_Dial *arg1 = (Fl_Line_Dial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Line_Dial *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Line_Dial_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Line_Dial *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Line_Dial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Menu_Bar_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Menu_Bar *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Bar_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Menu_Bar *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Bar_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Bar_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Bar * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Bar_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Menu_Bar::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Bar(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Menu_Bar *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Menu_Bar",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Bar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Bar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_Bar" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_Bar" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Menu_Bar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Menu_Bar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Bar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Menu_Bar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Bar *arg1 = (Fl_Menu_Bar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Menu_Bar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Menu_Bar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Menu_Button_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Menu_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Menu_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Button_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Button_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Menu_Button::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Button_popup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Button_popup",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Button * >(argp1);
  result = (Fl_Menu_Item *)(arg1)->popup();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Menu_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Menu_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Menu_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Menu_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Menu_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Button *arg1 = (Fl_Menu_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Menu_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Menu_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Menu_Item_next__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_next",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_next" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->next(arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_next",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_next" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (Fl_Menu_Item *)(arg1)->next(arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 1) && (argc <= 2)) {
    return _wrap_Fl_Menu_Item_next__SWIG_1(self, args);
  }
  if ((argc >= 1) && (argc <= 2)) {
    return _wrap_Fl_Menu_Item_next__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->first();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (Fl_Menu_Item *)(arg1)->first();
  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) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_first__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_first__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (char *)((Fl_Menu_Item const *)arg1)->label();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_label__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_label",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_label" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = static_cast< Fl_Labeltype >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  (arg1)->label(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_label__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_label__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Menu_Item_label__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_labeltype__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Labeltype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labeltype",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (Fl_Labeltype)((Fl_Menu_Item const *)arg1)->labeltype();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labeltype__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labeltype",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labeltype" "', argument " "2"" of type '" "Fl_Labeltype""'");
  } 
  arg2 = static_cast< Fl_Labeltype >(val2);
  (arg1)->labeltype(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labeltype(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_labeltype__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_labeltype__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labelcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (Fl_Color)((Fl_Menu_Item const *)arg1)->labelcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labelcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labelcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->labelcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_labelcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_labelcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labelfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (Fl_Font)((Fl_Menu_Item const *)arg1)->labelfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labelfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->labelfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_labelfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_labelfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labelsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (Fl_Fontsize)((Fl_Menu_Item const *)arg1)->labelsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_labelsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->labelsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_labelsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_labelsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_labelsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_callback",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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(obj2,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 *""'"); 
  }
  (arg1)->callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Callback *arg2 = (Fl_Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_callback",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 *""'"); 
    }
  }
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Callback0 *arg2 = (Fl_Callback0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_callback",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 *""'"); 
    }
  }
  (arg1)->callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_callback",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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 (obj2) {
    ecode3 = SWIG_AsVal_long(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_callback" "', argument " "3"" of type '" "long""'");
    } 
    arg3 = static_cast< long >(val3);
  }
  (arg1)->callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_user_data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_user_data",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (void *)((Fl_Menu_Item const *)arg1)->user_data();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_user_data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_user_data",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Menu_Item_user_data" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->user_data(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_argument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_argument",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (long)((Fl_Menu_Item const *)arg1)->argument();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_argument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_argument",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_argument" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->argument(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_argument(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_argument__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_argument__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->shortcut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_shortcut__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_shortcut",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->shortcut(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_shortcut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_shortcut__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_shortcut__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_submenu",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->submenu();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_checkbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_checkbox",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->checkbox();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_radio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_radio",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->radio();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->value();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_set",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->set();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_setonly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_setonly",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->setonly();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_visible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->visible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_show",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->show();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->hide();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_active",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->active();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_activate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_activate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->activate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_deactivate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_deactivate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->deactivate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_activevisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_activevisible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->activevisible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_image(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_image",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->image(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_measure(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_measure",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Menu_ * >(argp3);
  result = (int)((Fl_Menu_Item const *)arg1)->measure(arg2,(Fl_Menu_ const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_draw",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Menu_Item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &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 = reinterpret_cast< Fl_Menu_ * >(argp6);
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu_Item_draw" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  ((Fl_Menu_Item const *)arg1)->draw(arg2,arg3,arg4,arg5,(Fl_Menu_ const *)arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_popup(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_popup",3,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_popup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_popup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &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 = reinterpret_cast< Fl_Menu_Item * >(argp5);
  }
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &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 = reinterpret_cast< Fl_Menu_ * >(argp6);
  }
  result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->popup(arg2,arg3,(char const *)arg4,(Fl_Menu_Item const *)arg5,(Fl_Menu_ const *)arg6);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_pulldown",5,9,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_pulldown" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_pulldown" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_pulldown" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Menu_Item_pulldown" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &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 = reinterpret_cast< Fl_Menu_Item * >(argp6);
  }
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &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 = reinterpret_cast< Fl_Menu_ * >(argp7);
  }
  if (obj7) {
    res8 = SWIG_ConvertPtr(obj7, &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 = reinterpret_cast< Fl_Menu_Item * >(argp8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Fl_Menu_Item_pulldown" "', argument " "9"" of type '" "int""'");
    } 
    arg9 = static_cast< int >(val9);
  }
  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);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_test_shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->test_shortcut();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_find_shortcut",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_find_shortcut" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  result = (Fl_Menu_Item *)((Fl_Menu_Item const *)arg1)->find_shortcut(arg2,arg3);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_do_callback",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  ((Fl_Menu_Item const *)arg1)->do_callback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_do_callback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_do_callback",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  res3 = SWIG_ConvertPtr(obj2,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 *""'"); 
  }
  ((Fl_Menu_Item const *)arg1)->do_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_do_callback__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  Fl_Widget *arg2 = (Fl_Widget *) 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_do_callback",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  ecode3 = SWIG_AsVal_long(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_do_callback" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  ((Fl_Menu_Item const *)arg1)->do_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_do_callback(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_do_callback__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Menu_Item_do_callback__SWIG_1(self, args);
  }
check_2:
  
  if (argc == 3) {
    return _wrap_Fl_Menu_Item_do_callback__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *) const\n"
    "    Fl_Menu_Item::do_callback(Fl_Widget *,void *) const\n"
    "    Fl_Menu_Item::do_callback(Fl_Widget *,long) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_checked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_checked",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_checked" "', argument " "1"" of type '" "Fl_Menu_Item const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->checked();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_check",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_check" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->check();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_uncheck(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_uncheck",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Item_uncheck" "', argument " "1"" of type '" "Fl_Menu_Item *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  (arg1)->uncheck();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_insert",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Menu_Item_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Menu_Item_insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    int res = SWIG_ConvertFunctionPtr(obj4, (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 (obj5) {
    res6 = SWIG_ConvertPtr(obj5,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 (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Menu_Item_insert" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  result = (int)(arg1)->insert(arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_add",4,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Menu_Item_add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(obj3, (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 (obj4) {
    res5 = SWIG_ConvertPtr(obj4,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 (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Menu_Item_add" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  result = (int)(arg1)->add((char const *)arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_add",4,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  {
    int res = SWIG_ConvertFunctionPtr(obj3, (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 (obj4) {
    res5 = SWIG_ConvertPtr(obj4,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 (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Menu_Item_add" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  result = (int)(arg1)->add((char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< 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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Menu_Item_add__SWIG_0(self, args);
  }
check_1:
  
  if ((argc >= 4) && (argc <= 6)) {
    return _wrap_Fl_Menu_Item_add__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (int)((Fl_Menu_Item const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_callback",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (PyObject *)Fl_Menu_Item_callback__SWIG_4(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_callback(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_callback__SWIG_4(self, args);
  }
  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, args);
  }
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, args);
  }
check_3:
  
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_callback__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Menu_Item_callback__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Item_user_data",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  result = (PyObject *)Fl_Menu_Item_user_data__SWIG_2(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Item_user_data(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_user_data__SWIG_2(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Menu_Item_user_data__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Menu_Item_user_data__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Menu_Item_user_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Menu_Item::user_data() const\n"
    "    Fl_Menu_Item::user_data(void *)\n"
    "    Fl_Menu_Item::user_data()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Item(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Menu_Item",0,0)) SWIG_fail;
  result = (Fl_Menu_Item *)new Fl_Menu_Item();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Item *arg1 = (Fl_Menu_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Menu_Item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Item * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Menu_Item_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Menu_Item, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Single_Window_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Single_Window_flush",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Single_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Single_Window::flush();
    } else {
      (arg1)->flush();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Single_Window__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Single_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Single_Window",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Single_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Single_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Single_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Single_Window",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Single_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Single_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Single_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Single_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_new_Fl_Single_Window__SWIG_0(self, args);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Single_Window__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_show(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Single_Window_show",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Single_Window * >(argp1);
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Single_Window_show(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Single_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Single_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Single_Window * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Single_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Single_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Single_Window *arg1 = (Fl_Single_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Single_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Single_Window_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Single_Window *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Single_Window, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Menu_Window_erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Window_erase",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_erase" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Window * >(argp1);
  (arg1)->erase();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Window_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Window_flush",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_flush" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Menu_Window::flush();
    } else {
      (arg1)->flush();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Window_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Window_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_hide" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Menu_Window::hide();
    } else {
      (arg1)->hide();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Window_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Window_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_overlay" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Window * >(argp1);
  result = (unsigned int)(arg1)->overlay();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Window_set_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Window_set_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_set_overlay" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Window * >(argp1);
  (arg1)->set_overlay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Menu_Window_clear_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Window_clear_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Menu_Window, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Menu_Window_clear_overlay" "', argument " "1"" of type '" "Fl_Menu_Window *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Menu_Window * >(argp1);
  (arg1)->clear_overlay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Menu_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Menu_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Menu_Window * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Menu_Window__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Menu_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Menu_Window",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Menu_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Menu_Window",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Menu_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Menu_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Menu_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Menu_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_new_Fl_Menu_Window__SWIG_0(self, args);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Menu_Window__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_Menu_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Menu_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Menu_Window *arg1 = (Fl_Menu_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Menu_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Menu_Window_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Menu_Window *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Menu_Window, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Multiline_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Multiline_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Multiline_Input",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Multiline_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Multiline_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Multiline_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Multiline_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Multiline_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Input *arg1 = (Fl_Multiline_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Multiline_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multiline_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Multiline_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Input *arg1 = (Fl_Multiline_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Multiline_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Input *arg1 = (Fl_Multiline_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multiline_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multiline_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multiline_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Multiline_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Output(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Output *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Output",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Output *arg1 = (Fl_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Output * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Output *arg1 = (Fl_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Output *arg1 = (Fl_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Output *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Output_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Output *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Output, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Multiline_Output(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Multiline_Output *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Multiline_Output",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Multiline_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Multiline_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Multiline_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Multiline_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Multiline_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Output *arg1 = (Fl_Multiline_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Multiline_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multiline_Output * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Multiline_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Output *arg1 = (Fl_Multiline_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Multiline_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multiline_Output *arg1 = (Fl_Multiline_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multiline_Output *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multiline_Output_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multiline_Output *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Multiline_Output, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Multi_Browser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Multi_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Multi_Browser",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Multi_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Multi_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Multi_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Multi_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Multi_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Multi_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Multi_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Multi_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_prev",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_width(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_quick_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_quick_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Multi_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    if (upcall) {
      (darg)->item_swapSwigPublic(arg2,arg3);
    } else {
      (darg)->item_swap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_at",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Multi_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_full_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_full_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_full_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_incr_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Browser *arg1 = (Fl_Multi_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_incr_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_select",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Multi_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    if (upcall) {
      (darg)->item_selectSwigPublic(arg2,arg3);
    } else {
      (darg)->item_select(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Browser_item_selected(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Multi_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Browser_item_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Multi_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Multi_Browser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Multi_Browser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Multi_Label_label__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Label_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Label * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->label(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Label_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Multi_Label_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Label * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Menu_Item * >(argp2);
  (arg1)->label(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Multi_Label_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Multi_Label_label__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Label *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Multi_Label",0,0)) SWIG_fail;
  result = (Fl_Multi_Label *)new Fl_Multi_Label();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Multi_Label *arg1 = (Fl_Multi_Label *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Multi_Label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Multi_Label * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Multi_Label_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Multi_Label, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Nice_Slider(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Nice_Slider *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Nice_Slider",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Nice_Slider" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Nice_Slider" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Nice_Slider" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Nice_Slider" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Nice_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Nice_Slider *arg1 = (Fl_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Nice_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Nice_Slider * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Nice_Slider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Nice_Slider *arg1 = (Fl_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Nice_Slider",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Nice_Slider *arg1 = (Fl_Nice_Slider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Nice_Slider *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Nice_Slider_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Nice_Slider *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Nice_Slider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_draw_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Overlay_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_draw_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("draw_overlay"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member draw_overlay");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Overlay_Window *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Fl_Overlay_Window::draw_overlay");
    } else {
      (darg)->draw_overlay();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_flush",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Overlay_Window::flush();
    } else {
      (arg1)->flush();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_hide",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Overlay_Window::hide();
    } else {
      (arg1)->hide();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Overlay_Window_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Overlay_Window_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Overlay_Window_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Overlay_Window_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Overlay_Window::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Overlay_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Overlay_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_can_do_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_can_do_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  result = (int)(arg1)->can_do_overlay();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Overlay_Window_redraw_overlay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_redraw_overlay",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  (arg1)->redraw_overlay();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Overlay_Window__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Overlay_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Overlay_Window",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Overlay_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Overlay_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  }
  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;
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Overlay_Window *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Overlay_Window",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Overlay_Window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Overlay_Window" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Overlay_Window" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Overlay_Window" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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;
  }
  
  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) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 3) && (argc <= 4)) {
    return _wrap_new_Fl_Overlay_Window__SWIG_0(self, args);
  }
  if ((argc >= 5) && (argc <= 6)) {
    return _wrap_new_Fl_Overlay_Window__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_show(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_show",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Overlay_Window * >(argp1);
  if (obj1) {
    arg2 = obj1;
  }
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Overlay_Window_show(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Overlay_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Overlay_Window",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Overlay_Window *arg1 = (Fl_Overlay_Window *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Overlay_Window *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Overlay_Window_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Overlay_Window *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Overlay_Window, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Pack_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Pack *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pack_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Pack *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Pack(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Pack *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Pack",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Pack" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Pack" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Pack" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Pack" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pack_spacing",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pack * >(argp1);
  result = (int)((Fl_Pack const *)arg1)->spacing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_spacing__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pack_spacing",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pack * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Pack_spacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->spacing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Pack_spacing(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Pack_spacing__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Pack_spacing__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Pack_horizontal",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pack * >(argp1);
  result = (uchar)((Fl_Pack const *)arg1)->horizontal();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Pack",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Pack * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Pack *arg1 = (Fl_Pack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Pack",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Pack, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_PNG_Image__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_PNG_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_PNG_Image",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_PNG_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_PNG_Image",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  {
    /* Check if the input support the buffer protocol */
    Py_ssize_t size_buffer;
    const void * buffer;
    int failure = PyObject_AsReadBuffer(obj2,&buffer,&size_buffer);
    if (!failure) {
      // work with array object
      arg3 = (uchar *) buffer;
    } else {
      // work with list object
      // clear the error from PyObject_AsReadBuffer
      PyErr_Clear();
      size_buffer=0;
      buffer=0;
      /* Check if is a list */
      if (PyList_Check(obj2)) {
        int size = PyList_Size(obj2);
        int i = 0;
        arg3 = (uchar *) malloc((size+1)*sizeof(char));
        for (i = 0; i < size; i++) {
          PyObject *o = 	PyList_GetItem(obj2,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(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_PNG_Image" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  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); 
  }
  
  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) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_new_Fl_PNG_Image__SWIG_0(self, args);
  }
  if (argc == 4) {
    return _wrap_new_Fl_PNG_Image__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNG_Image *arg1 = (Fl_PNG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_PNG_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_PNG_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_PNG_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNG_Image *arg1 = (Fl_PNG_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_PNG_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_PNG_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_PNM_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_PNM_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_PNM_Image",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNM_Image *arg1 = (Fl_PNM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_PNM_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_PNM_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_PNM_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_PNM_Image *arg1 = (Fl_PNM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_PNM_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_PNM_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Positioner_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Positioner *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Positioner *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Positioner::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Positioner(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Positioner *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Positioner",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Positioner" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Positioner" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Positioner" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Positioner" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xvalue",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  result = (double)((Fl_Positioner const *)arg1)->xvalue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yvalue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_yvalue",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  result = (double)((Fl_Positioner const *)arg1)->yvalue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xvalue__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xvalue",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xvalue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->xvalue(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xvalue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Positioner_xvalue__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Positioner_xvalue__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_yvalue",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_yvalue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->yvalue(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yvalue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Positioner_yvalue__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Positioner_yvalue__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_value",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Positioner_value" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (int)(arg1)->value(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xbounds(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xbounds",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xbounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Positioner_xbounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->xbounds(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xminimum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xminimum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  result = (double)((Fl_Positioner const *)arg1)->xminimum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xminimum__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xminimum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xminimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xminimum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xminimum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Positioner_xminimum__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Positioner_xminimum__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xmaximum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  result = (double)((Fl_Positioner const *)arg1)->xmaximum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xmaximum__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xmaximum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xmaximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xmaximum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_xmaximum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Positioner_xmaximum__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Positioner_xmaximum__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_ybounds",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_ybounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Positioner_ybounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->ybounds(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yminimum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_yminimum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  result = (double)((Fl_Positioner const *)arg1)->yminimum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yminimum__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_yminimum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_yminimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->yminimum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_yminimum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Positioner_yminimum__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Positioner_yminimum__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_ymaximum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  result = (double)((Fl_Positioner const *)arg1)->ymaximum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ymaximum__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_ymaximum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_ymaximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->ymaximum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ymaximum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Positioner_ymaximum__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Positioner_ymaximum__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_xstep",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_xstep" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xstep(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Positioner_ystep(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Positioner_ystep",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Positioner_ystep" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->ystep(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Positioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Positioner",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Positioner * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Positioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Positioner *arg1 = (Fl_Positioner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Positioner",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Positioner, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Preferences__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Preferences *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Preferences",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Preferences" "', argument " "1"" of type '" "Fl_Preferences::Root""'");
  } 
  arg1 = static_cast< Fl_Preferences::Root >(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (Fl_Preferences *)new Fl_Preferences(arg1,(char const *)arg2,(char const *)arg3);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Preferences *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Preferences",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Preferences" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fl_Preferences" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (Fl_Preferences *)new Fl_Preferences((char const *)arg1,(char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Preferences, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Preferences__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Preferences *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Preferences",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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_ValueError, "invalid null reference " "in method '" "new_Fl_Preferences" "', argument " "1"" of type '" "Fl_Preferences &""'"); 
  }
  arg1 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (Fl_Preferences *)new Fl_Preferences(*arg1,(char const *)arg2);
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_new_Fl_Preferences__SWIG_2(self, args);
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_Fl_Preferences__SWIG_0(self, args);
  }
check_2:
  
  if (argc == 3) {
    return _wrap_new_Fl_Preferences__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(char const *,char const *,char const *)\n"
    "    Fl_Preferences::Fl_Preferences(Fl_Preferences &,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Preferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Preferences",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_groups(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_groups",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  result = (int)(arg1)->groups();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_group(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_group",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Preferences_group" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)(arg1)->group(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_groupExists(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_groupExists",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (char)(arg1)->groupExists((char const *)arg2);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_deleteGroup(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_deleteGroup",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (char)(arg1)->deleteGroup((char const *)arg2);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_entries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_entries",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  result = (int)(arg1)->entries();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_entry(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_entry",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Preferences_entry" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)(arg1)->entry(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_entryExists(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_entryExists",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (char)(arg1)->entryExists((char const *)arg2);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_deleteEntry(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_deleteEntry",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (char)(arg1)->deleteEntry((char const *)arg2);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_set",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (char)(arg1)->set((char const *)arg2,arg3);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_set",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (char)(arg1)->set((char const *)arg2,arg3,arg4);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_set",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (char)(arg1)->set((char const *)arg2,arg3);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_set",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Preferences_set" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (char)(arg1)->set((char const *)arg2,arg3,arg4);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_set",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (char)(arg1)->set((char const *)arg2,(char const *)arg3);
  {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_set",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(obj2,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(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (char)(arg1)->set((char const *)arg2,(void const *)arg3,arg4);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_set(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
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, args);
  }
check_2:
  
  if (argc == 3) {
    return _wrap_Fl_Preferences_set__SWIG_4(self, args);
  }
  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;
    return _wrap_Fl_Preferences_set__SWIG_5(self, args);
  }
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;
    return _wrap_Fl_Preferences_set__SWIG_1(self, args);
  }
check_5:
  
  if (argc == 4) {
    return _wrap_Fl_Preferences_set__SWIG_3(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char result;
  
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_get",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode4 = SWIG_AsVal_int(obj2, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (char)(arg1)->get((char const *)arg2,*arg3,arg4);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char result;
  
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_get",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode4 = SWIG_AsVal_float(obj2, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (char)(arg1)->get((char const *)arg2,*arg3,arg4);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char result;
  
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_get",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode4 = SWIG_AsVal_double(obj2, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Preferences_get" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (char)(arg1)->get((char const *)arg2,*arg3,arg4);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char result;
  
  arg3 = (char *) temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_get",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res4 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_int(obj3, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Preferences_get" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (char)(arg1)->get((char const *)arg2,arg3,(char const *)arg4,arg5);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  arg3[1024] = 0;  
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg3));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_get",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(obj2,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(obj3,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(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Preferences_get" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Preferences_get" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (char)(arg1)->get((char const *)arg2,arg3,(void const *)arg4,arg5,arg6);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_get(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[7];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
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, args);
  }
check_2:
  
  if (argc == 3) {
    return _wrap_Fl_Preferences_get__SWIG_2(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_Preferences_get__SWIG_3(self, args);
  }
  if (argc == 6) {
    return _wrap_Fl_Preferences_get__SWIG_4(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->size((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_getUserdataPath(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_getUserdataPath",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  res2 = SWIG_AsVal_size_t (obj1, &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 = static_cast< int >(size2);
  arg2 = static_cast< char * >(buff2);
  result = (char)(arg1)->getUserdataPath(arg2,arg3);
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg2));
  if (buff2) delete[] buff2;
  return resultobj;
fail:
  if (buff2) delete[] buff2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Preferences_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Preferences *arg1 = (Fl_Preferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Preferences_flush",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Preferences * >(argp1);
  (arg1)->flush();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Preferences_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Preferences, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Progress_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Progress *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Progress_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Progress *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Progress(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Progress *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Progress",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Progress" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Progress" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Progress" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Progress" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Progress_maximum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Progress * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Progress_maximum" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->maximum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_maximum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  float result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Progress_maximum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Progress * >(argp1);
  result = (float)((Fl_Progress const *)arg1)->maximum();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_maximum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Progress_maximum__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Progress_maximum__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Progress_minimum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Progress * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Progress_minimum" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->minimum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_minimum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  float result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Progress_minimum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Progress * >(argp1);
  result = (float)((Fl_Progress const *)arg1)->minimum();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_minimum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Progress_minimum__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Progress_minimum__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Progress_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Progress * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Progress_value" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  float result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Progress_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Progress * >(argp1);
  result = (float)((Fl_Progress const *)arg1)->value();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Progress_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Progress_value__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Progress_value__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Progress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Progress",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Progress * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Progress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Progress *arg1 = (Fl_Progress *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Progress",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Progress, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Radio_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Radio_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Radio_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Radio_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Radio_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Radio_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Radio_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Radio_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Button *arg1 = (Fl_Radio_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Radio_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Radio_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Radio_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Button *arg1 = (Fl_Radio_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Radio_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Button *arg1 = (Fl_Radio_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Radio_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Radio_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Radio_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Radio_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Radio_Light_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Radio_Light_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Radio_Light_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Radio_Light_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Radio_Light_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Radio_Light_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Radio_Light_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Radio_Light_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Light_Button *arg1 = (Fl_Radio_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Radio_Light_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Radio_Light_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Radio_Light_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Light_Button *arg1 = (Fl_Radio_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Radio_Light_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Light_Button *arg1 = (Fl_Radio_Light_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Radio_Light_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Radio_Light_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Radio_Light_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Radio_Light_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Round_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Round_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Round_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Round_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Round_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Round_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Round_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Round_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Button *arg1 = (Fl_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Round_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Round_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Round_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Button *arg1 = (Fl_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Round_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Button *arg1 = (Fl_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Round_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Round_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Round_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Round_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Radio_Round_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Radio_Round_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Radio_Round_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Radio_Round_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Radio_Round_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Radio_Round_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Radio_Round_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Radio_Round_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Round_Button *arg1 = (Fl_Radio_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Radio_Round_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Radio_Round_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Radio_Round_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Round_Button *arg1 = (Fl_Radio_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Radio_Round_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Radio_Round_Button *arg1 = (Fl_Radio_Round_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Radio_Round_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Radio_Round_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Radio_Round_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Radio_Round_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Repeat_Button_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Repeat_Button_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Repeat_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Repeat_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Repeat_Button::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Repeat_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Repeat_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Repeat_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Repeat_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Repeat_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Repeat_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Repeat_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Repeat_Button_deactivate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Repeat_Button * >(argp1);
  (arg1)->deactivate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Repeat_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Repeat_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Repeat_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Repeat_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Repeat_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Repeat_Button *arg1 = (Fl_Repeat_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Repeat_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Repeat_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Repeat_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Repeat_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Return_Button_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Return_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Return_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Return_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Return_Button_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Return_Button_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Return_Button * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Return_Button_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Return_Button::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Return_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Return_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Return_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Return_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Return_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Return_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Return_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Return_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Return_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Return_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Return_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Return_Button *arg1 = (Fl_Return_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Return_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Return_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Roller_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Roller *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Roller_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Roller *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Roller_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Roller_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Roller * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Roller_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Roller::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Roller(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Roller *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Roller",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Roller" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Roller" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Roller" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Roller" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Roller(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Roller",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Roller * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Roller(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Roller *arg1 = (Fl_Roller *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Roller",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Roller, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Round_Clock(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Round_Clock *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Round_Clock",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Round_Clock" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Round_Clock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Round_Clock" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Round_Clock" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Round_Clock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Clock *arg1 = (Fl_Round_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Round_Clock",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Round_Clock * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Round_Clock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Clock *arg1 = (Fl_Round_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Round_Clock",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Round_Clock *arg1 = (Fl_Round_Clock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Round_Clock *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Round_Clock_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Round_Clock *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Round_Clock, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Scroll_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Scroll *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Scroll *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Scroll_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Scroll_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Scroll_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Scroll::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Scroll::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Scroll(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Scroll *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Scroll",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Scroll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Scroll" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Scroll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Scroll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_Fl_Scroll_xposition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_xposition",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  result = (int)((Fl_Scroll const *)arg1)->xposition();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_yposition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_yposition",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  result = (int)((Fl_Scroll const *)arg1)->yposition();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scroll_to(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_scroll_to",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_scroll_to" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Scroll_scroll_to" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->scroll_to(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scrollbar_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_scrollbar_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  result = (int)((Fl_Scroll const *)arg1)->scrollbar_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scrollbar_size__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_scrollbar_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scroll_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->scrollbar_size(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scroll_scrollbar_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Scroll_scrollbar_size__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Scroll_scrollbar_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_getScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Scrollbar *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_getScrollbar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  result = (Fl_Scrollbar *)Fl_Scroll_getScrollbar(arg1);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Scrollbar *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scroll_getHScrollbar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  result = (Fl_Scrollbar *)Fl_Scroll_getHScrollbar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Scrollbar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Scroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Scroll",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scroll * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Scroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scroll *arg1 = (Fl_Scroll *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Scroll",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Scroll, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Scrollbar_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Scrollbar *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scrollbar_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Scrollbar *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Scrollbar(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Scrollbar *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Scrollbar",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Scrollbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Scrollbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Scrollbar" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Scrollbar" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Scrollbar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scrollbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scrollbar_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scrollbar * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Scrollbar::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scrollbar_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scrollbar * >(argp1);
  result = (int)((Fl_Scrollbar const *)arg1)->value();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scrollbar_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scrollbar * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->value(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scrollbar_value",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scrollbar * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Scrollbar_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Scrollbar_value" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Scrollbar_value" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (int)(arg1)->value(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Scrollbar_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Scrollbar_value__SWIG_1(self, args);
  }
  if (argc == 5) {
    return _wrap_Fl_Scrollbar_value__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scrollbar_linesize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scrollbar * >(argp1);
  result = (int)((Fl_Scrollbar const *)arg1)->linesize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_linesize__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Scrollbar_linesize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Scrollbar * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Scrollbar_linesize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->linesize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Scrollbar_linesize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Scrollbar_linesize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Scrollbar_linesize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_disown_Fl_Scrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Scrollbar *arg1 = (Fl_Scrollbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Scrollbar",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Scrollbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Secret_Input(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Secret_Input *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Secret_Input",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Secret_Input" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Secret_Input" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Secret_Input" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Secret_Input" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Secret_Input_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Secret_Input * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Secret_Input_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Secret_Input::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Secret_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Secret_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Secret_Input * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Secret_Input(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Secret_Input",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Secret_Input *arg1 = (Fl_Secret_Input *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Secret_Input *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Secret_Input_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Secret_Input *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Secret_Input, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Select_Browser(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Select_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Select_Browser",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Select_Browser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Select_Browser" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Select_Browser" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Select_Browser" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Select_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Select_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Select_Browser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Select_Browser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_first(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_prev",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_width(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_quick_height(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_quick_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_draw(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_draw",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Select_Browser_item_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Select_Browser_item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Select_Browser_item_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Select_Browser_item_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_text",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    if (upcall) {
      (darg)->item_swapSwigPublic(arg2,arg3);
    } else {
      (darg)->item_swap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_at",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Select_Browser_item_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_full_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_full_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_full_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_incr_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Select_Browser *arg1 = (Fl_Select_Browser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_incr_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_select",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Select_Browser_item_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    if (upcall) {
      (darg)->item_selectSwigPublic(arg2,arg3);
    } else {
      (darg)->item_select(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Select_Browser_item_selected(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Select_Browser *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Select_Browser_item_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Select_Browser * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Select_Browser *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Select_Browser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Select_Browser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Shared_Image__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Fl_Shared_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Shared_Image",1,1,&obj0)) SWIG_fail;
  arg1 = obj0;
  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;
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Shared_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Shared_Image",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Image * >(argp3);
  }
  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;
  }
  
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_new_Fl_Shared_Image__SWIG_0(self, args);
  }
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_new_Fl_Shared_Image__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_name",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  result = (char *)(arg1)->name();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_refcount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_refcount",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  result = (int)(arg1)->refcount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_release",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  (arg1)->release();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_reload(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_reload",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  (arg1)->reload();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_copy",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Image *)(arg1)->Fl_Shared_Image::copy(arg2,arg3);
    } else {
      result = (Fl_Image *)(arg1)->copy(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_copy",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  result = (Fl_Image *)(arg1)->copy();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Shared_Image_copy__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Shared_Image_copy__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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)\n"
    "    Fl_Shared_Image::copy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_color_average(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_color_average",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Shared_Image::color_average(arg2,arg3);
    } else {
      (arg1)->color_average(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_desaturate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_desaturate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Shared_Image::desaturate();
    } else {
      (arg1)->desaturate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_draw",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Shared_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Shared_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Shared_Image_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Shared_Image_draw" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->draw(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_Shared_Image_draw__SWIG_1(self, args);
  }
  if (argc == 7) {
    return _wrap_Fl_Shared_Image_draw__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_scale",3,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Shared_Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Shared_Image_scale" "', argument " "1"" of type '" "Fl_Shared_Image *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_scale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_scale" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Shared_Image_scale" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Shared_Image_scale" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  (arg1)->scale(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_uncache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_uncache",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Shared_Image * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Shared_Image::uncache();
    } else {
      (arg1)->uncache();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_find(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  Fl_Shared_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_find",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_find" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_find" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (Fl_Shared_Image *)Fl_Shared_Image::find((char const *)arg1,arg2,arg3);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  Fl_Shared_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_get",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_get" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Shared_Image_get" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (Fl_Shared_Image *)Fl_Shared_Image::get((char const *)arg1,arg2,arg3);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  Fl_Shared_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_get",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_RGB_Image * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Shared_Image_get" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (Fl_Shared_Image *)Fl_Shared_Image::get(arg1,arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Shared_Image_get__SWIG_1(self, args);
  }
check_1:
  
  if ((argc >= 1) && (argc <= 3)) {
    return _wrap_Fl_Shared_Image_get__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image **result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_images",0,0)) SWIG_fail;
  result = (Fl_Shared_Image **)Fl_Shared_Image::images();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_num_images",0,0)) SWIG_fail;
  result = (int)Fl_Shared_Image::num_images();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_add_handler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Handler arg1 = (Fl_Shared_Handler) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_add_handler",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (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""'"); 
    }
  }
  Fl_Shared_Image::add_handler(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_remove_handler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Handler arg1 = (Fl_Shared_Handler) 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_remove_handler",1,1,&obj0)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(obj0, (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""'"); 
    }
  }
  Fl_Shared_Image::remove_handler(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Shared_Image_scaling_algorithm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_RGB_Scaling arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Shared_Image_scaling_algorithm",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Shared_Image_scaling_algorithm" "', argument " "1"" of type '" "Fl_RGB_Scaling""'");
  } 
  arg1 = static_cast< Fl_RGB_Scaling >(val1);
  Fl_Shared_Image::scaling_algorithm(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Shared_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Shared_Image *arg1 = (Fl_Shared_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Shared_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Shared_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fl_register_images(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_register_images",0,0)) SWIG_fail;
  fl_register_images();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Spinner(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Spinner *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Spinner",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Spinner" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Spinner" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Spinner" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Spinner" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_format__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_format",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (char *)(arg1)->format();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_format__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_format",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->format((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_format(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_format__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_format__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Spinner_format'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::format()\n"
    "    Fl_Spinner::format(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Spinner::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maxinum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_maxinum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_maxinum" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (double)((Fl_Spinner const *)arg1)->maxinum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_mininum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_mininum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Spinner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Spinner_mininum" "', argument " "1"" of type '" "Fl_Spinner const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (double)((Fl_Spinner const *)arg1)->mininum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_range(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_range",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_range" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Spinner_range" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->range(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Spinner_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Spinner_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Spinner_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Spinner::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_step__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_step",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (double)((Fl_Spinner const *)arg1)->step();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_step__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_step",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_step" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->step(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_step(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_step__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_step__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Spinner_step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::step() const\n"
    "    Fl_Spinner::step(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textcolor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (Fl_Color)((Fl_Spinner const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (Fl_Font)((Fl_Spinner const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (Fl_Fontsize)((Fl_Spinner const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_type",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (uchar)((Fl_Spinner const *)arg1)->type();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_type__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_type",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_type" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->type(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_type(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_type__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_type__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Spinner_type'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Spinner::type() const\n"
    "    Fl_Spinner::type(uchar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (double)((Fl_Spinner const *)arg1)->value();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (Fl_Color)((Fl_Spinner const *)arg1)->color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_color__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_color__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_selection_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_selection_color" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->selection_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_selection_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_selection_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (Fl_Color)((Fl_Spinner const *)arg1)->selection_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_selection_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_selection_color__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_selection_color__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_minimum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_minimum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_minimum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  Fl_Spinner_min__SWIG_0(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_minimum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_minimum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (double)Fl_Spinner_min__SWIG_1(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_minimum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_minimum__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_minimum__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_maximum",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Spinner_maximum" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  Fl_Spinner_max__SWIG_0(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_maximum",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  result = (double)Fl_Spinner_max__SWIG_1(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Spinner_maximum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Spinner_maximum__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Spinner_maximum__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Spinner",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Spinner * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Spinner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Spinner",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *_wrap_Fl_Spinner_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Spinner *arg1 = (Fl_Spinner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Spinner *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Spinner_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Spinner *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Spinner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Spinner, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fl_show_colormap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_show_colormap",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_show_colormap" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  result = (Fl_Color)fl_show_colormap(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Simple_Counter(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Simple_Counter *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Simple_Counter",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Simple_Counter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Simple_Counter" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Simple_Counter" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Simple_Counter" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Simple_Counter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Simple_Counter *arg1 = (Fl_Simple_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Simple_Counter",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Simple_Counter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Simple_Counter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Simple_Counter *arg1 = (Fl_Simple_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Simple_Counter",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Simple_Counter *arg1 = (Fl_Simple_Counter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Simple_Counter *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Simple_Counter_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Simple_Counter *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Simple_Counter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Tabs_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tabs *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tabs *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Tabs::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  result = (Fl_Widget *)(arg1)->value();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (int)(arg1)->value(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tabs_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tabs_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_push",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  result = (Fl_Widget *)((Fl_Tabs const *)arg1)->push();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_push",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (int)(arg1)->push(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_push(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tabs_push__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tabs_push__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_new_Fl_Tabs(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Tabs *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tabs",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Tabs" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tabs" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tabs" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Tabs" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_Fl_Tabs_which(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_which",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tabs_which" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tabs_which" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Fl_Widget *)(arg1)->which(arg2,arg3);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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_delete_Fl_Tabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tabs",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tabs_client_area(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tabs_client_area",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tabs * >(argp1);
  if (obj1) {
    ecode6 = SWIG_AsVal_int(obj1, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tabs_client_area" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  (arg1)->client_area(*arg2,*arg3,*arg4,*arg5,arg6);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tabs *arg1 = (Fl_Tabs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Tabs",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tabs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Text_Selection_set(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_set",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Selection_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->set(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_update(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_update",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_update" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Selection_update" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Selection_update" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->update(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_start",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  result = (int)((Fl_Text_Selection const *)arg1)->start();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_end",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  result = (int)((Fl_Text_Selection const *)arg1)->end();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_selected__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_selected",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  result = (bool)((Fl_Text_Selection const *)arg1)->selected();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_selected__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_selected" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->selected(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_selected(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Selection_selected__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Selection_selected__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_includes(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_includes",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Selection_includes" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Selection const *)arg1)->includes(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Selection_position(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Selection_position",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Text_Selection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Text_Selection_position" "', argument " "1"" of type '" "Fl_Text_Selection const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Text_Selection_position" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Text_Selection_position" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (int)((Fl_Text_Selection const *)arg1)->position(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Text_Selection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Text_Selection",0,0)) SWIG_fail;
  result = (Fl_Text_Selection *)new Fl_Text_Selection();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Selection *arg1 = (Fl_Text_Selection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Text_Selection",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Selection * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Text_Selection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Text_Selection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Text_Buffer(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Text_Buffer *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Text_Buffer",0,2,&obj0,&obj1)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_int(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Text_Buffer" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Text_Buffer" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  result = (Fl_Text_Buffer *)new Fl_Text_Buffer(arg1,arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Text_Buffer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_length",1,1,&obj0)) 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_length" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (int)((Fl_Text_Buffer const *)arg1)->length();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_text",1,1,&obj0)) 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_text" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (char *)((Fl_Text_Buffer const *)arg1)->text();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_text",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_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_text" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->text((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_text(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Buffer_text__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Buffer_text__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_text_range",3,3,&obj0,&obj1,&obj2)) 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_text_range" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_text_range" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_text_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (char *)((Fl_Text_Buffer const *)arg1)->text_range(arg2,arg3);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_char_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_char_at",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_char_at" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_char_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (unsigned int)((Fl_Text_Buffer const *)arg1)->char_at(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_byte_at(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_byte_at",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_byte_at" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_byte_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char)((Fl_Text_Buffer const *)arg1)->byte_at(arg2);
  resultobj = SWIG_NewPointerObj((new char(static_cast< const char& >(result))), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_address__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_address",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_address" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_address" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)((Fl_Text_Buffer const *)arg1)->address(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_address__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_address",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_address" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_address" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)(arg1)->address(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_address(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Buffer_address__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Buffer_address__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_insert",3,3,&obj0,&obj1,&obj2)) 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_insert" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  (arg1)->insert(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_append(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_append",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_append" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_append" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->append((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_remove",3,3,&obj0,&obj1,&obj2)) 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_remove" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_remove" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->remove(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  int arg2 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_replace",4,4,&obj0,&obj1,&obj2,&obj3)) 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_replace" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_replace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &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 = reinterpret_cast< char * >(buf4);
  (arg1)->replace(arg2,arg3,(char const *)arg4);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_copy(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_copy",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_copy" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Buffer * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_copy" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_copy" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->copy(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_undo(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_undo",1,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_undo" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  }
  result = (int)(arg1)->undo(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_canUndo(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_canUndo",1,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_canUndo" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_char(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_canUndo" "', argument " "2"" of type '" "char""'");
    } 
    arg2 = static_cast< char >(val2);
  }
  (arg1)->canUndo(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_insertfile(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_insertfile",3,4,&obj0,&obj1,&obj2,&obj3)) 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_insertfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_insertfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_insertfile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_insertfile" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  result = (int)(arg1)->insertfile((char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_appendfile(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_appendfile",2,3,&obj0,&obj1,&obj2)) 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_appendfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_appendfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_appendfile" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->appendfile((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_loadfile(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_loadfile",2,3,&obj0,&obj1,&obj2)) 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_loadfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_loadfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_loadfile" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->loadfile((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_outputfile(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_outputfile",4,5,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_outputfile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_outputfile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_outputfile" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  result = (int)(arg1)->outputfile((char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_savefile(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_savefile",2,3,&obj0,&obj1,&obj2)) 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_savefile" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_savefile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_savefile" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->savefile((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_tab_distance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_tab_distance",1,1,&obj0)) 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_tab_distance" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (int)((Fl_Text_Buffer const *)arg1)->tab_distance();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_tab_distance__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_tab_distance",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_tab_distance" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_tab_distance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->tab_distance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_tab_distance(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Buffer_tab_distance__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Buffer_tab_distance__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_select",3,3,&obj0,&obj1,&obj2)) 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_select" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_select" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->select(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_selected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_selected",1,1,&obj0)) 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_selected" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (int)((Fl_Text_Buffer const *)arg1)->selected();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_unselect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_unselect",1,1,&obj0)) 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_unselect" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  (arg1)->unselect();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_selection_position(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_selection_position",3,3,&obj0,&obj1,&obj2)) 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_selection_position" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< int * >(argp3);
  result = (int)(arg1)->selection_position(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_selection_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_selection_text",1,1,&obj0)) 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_selection_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (char *)(arg1)->selection_text();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_selection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_remove_selection",1,1,&obj0)) 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_remove_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  (arg1)->remove_selection();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_replace_selection(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_replace_selection",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_replace_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_replace_selection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->replace_selection((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_secondary_select",3,3,&obj0,&obj1,&obj2)) 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_secondary_select" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_secondary_select" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_secondary_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->secondary_select(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_selected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_secondary_selected",1,1,&obj0)) 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_secondary_selected" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (int)(arg1)->secondary_selected();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_unselect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_secondary_unselect",1,1,&obj0)) 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_secondary_unselect" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  (arg1)->secondary_unselect();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_selection_position(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_secondary_selection_position",3,3,&obj0,&obj1,&obj2)) 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_secondary_selection_position" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< int * >(argp3);
  result = (int)(arg1)->secondary_selection_position(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_secondary_selection_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_secondary_selection_text",1,1,&obj0)) 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_secondary_selection_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (char *)(arg1)->secondary_selection_text();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_secondary_selection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_remove_secondary_selection",1,1,&obj0)) 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_remove_secondary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  (arg1)->remove_secondary_selection();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_replace_secondary_selection(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_replace_secondary_selection",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_replace_secondary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< 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_replace_secondary_selection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->replace_secondary_selection((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_highlight",3,3,&obj0,&obj1,&obj2)) 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_highlight" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_highlight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_highlight" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->highlight(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_highlight",1,1,&obj0)) 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_highlight" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (int)(arg1)->highlight();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Buffer_highlight__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Text_Buffer_highlight__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_unhighlight",1,1,&obj0)) 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_unhighlight" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  (arg1)->unhighlight();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight_position(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_highlight_position",3,3,&obj0,&obj1,&obj2)) 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_highlight_position" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< int * >(argp3);
  result = (int)(arg1)->highlight_position(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_highlight_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_highlight_text",1,1,&obj0)) 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_highlight_text" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (char *)(arg1)->highlight_text();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_modify_callback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_add_modify_callback",3,3,&obj0,&obj1,&obj2)) 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_add_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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(obj2,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 *""'"); 
  }
  (arg1)->add_modify_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_modify_callback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_remove_modify_callback",3,3,&obj0,&obj1,&obj2)) 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_remove_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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(obj2,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 *""'"); 
  }
  (arg1)->remove_modify_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_call_modify_callbacks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_call_modify_callbacks",1,1,&obj0)) 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_call_modify_callbacks" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  (arg1)->call_modify_callbacks();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_predelete_callback(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_add_predelete_callback",3,3,&obj0,&obj1,&obj2)) 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_add_predelete_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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(obj2,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 *""'"); 
  }
  (arg1)->add_predelete_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_predelete_callback(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_remove_predelete_callback",3,3,&obj0,&obj1,&obj2)) 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_remove_predelete_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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(obj2,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 *""'"); 
  }
  (arg1)->remove_predelete_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_call_predelete_callbacks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_call_predelete_callbacks",1,1,&obj0)) 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_call_predelete_callbacks" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  (arg1)->call_predelete_callbacks();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_line_text(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_line_text",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_line_text" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_line_text" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)((Fl_Text_Buffer const *)arg1)->line_text(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_line_start(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_line_start",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_line_start" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_line_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->line_start(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_line_end(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_line_end",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_line_end" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_line_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->line_end(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_word_start(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_word_start",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_word_start" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_word_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->word_start(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_word_end(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_word_end",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_word_end" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_word_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->word_end(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_count_displayed_characters(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_count_displayed_characters",3,3,&obj0,&obj1,&obj2)) 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_count_displayed_characters" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &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 = static_cast< int >(val3);
  result = (int)((Fl_Text_Buffer const *)arg1)->count_displayed_characters(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_skip_displayed_characters(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_skip_displayed_characters",3,3,&obj0,&obj1,&obj2)) 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_skip_displayed_characters" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &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 = static_cast< int >(val3);
  result = (int)(arg1)->skip_displayed_characters(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_count_lines(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_count_lines",3,3,&obj0,&obj1,&obj2)) 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_count_lines" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_count_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_count_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Fl_Text_Buffer const *)arg1)->count_lines(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_skip_lines(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_skip_lines",3,3,&obj0,&obj1,&obj2)) 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_skip_lines" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_skip_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_skip_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->skip_lines(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_rewind_lines(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_rewind_lines",3,3,&obj0,&obj1,&obj2)) 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_rewind_lines" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_rewind_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Buffer_rewind_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->rewind_lines(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_findchar_forward(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  arg4 = &temp4;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_findchar_forward",3,3,&obj0,&obj1,&obj2)) 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_findchar_forward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_findchar_forward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &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 = static_cast< unsigned int >(val3);
  result = (int)((Fl_Text_Buffer const *)arg1)->findchar_forward(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_findchar_backward(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  arg4 = &temp4;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_findchar_backward",3,3,&obj0,&obj1,&obj2)) 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_findchar_backward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_findchar_backward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &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 = static_cast< unsigned int >(val3);
  result = (int)((Fl_Text_Buffer const *)arg1)->findchar_backward(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_search_forward(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  arg4 = &temp4;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_search_forward",3,4,&obj0,&obj1,&obj2,&obj3)) 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_search_forward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_search_forward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  if (obj3) {
    ecode5 = SWIG_AsVal_int(obj3, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_search_forward" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  result = (int)((Fl_Text_Buffer const *)arg1)->search_forward(arg2,(char const *)arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_search_backward(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  arg4 = &temp4;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_search_backward",3,4,&obj0,&obj1,&obj2,&obj3)) 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_search_backward" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_search_backward" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  if (obj3) {
    ecode5 = SWIG_AsVal_int(obj3, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Buffer_search_backward" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  result = (int)((Fl_Text_Buffer const *)arg1)->search_backward(arg2,(char const *)arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_primary_selection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Text_Selection *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_primary_selection",1,1,&obj0)) 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_primary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (Fl_Text_Selection *)((Fl_Text_Buffer const *)arg1)->primary_selection();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Text_Selection *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_primary_selection",1,1,&obj0)) 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_primary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (Fl_Text_Selection *)(arg1)->primary_selection();
  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) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Buffer_primary_selection__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Buffer_primary_selection__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Text_Selection *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_secondary_selection",1,1,&obj0)) 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_secondary_selection" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (Fl_Text_Selection *)((Fl_Text_Buffer const *)arg1)->secondary_selection();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Buffer *arg1 = (Fl_Text_Buffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Text_Selection *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_highlight_selection",1,1,&obj0)) 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_highlight_selection" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  result = (Fl_Text_Selection *)((Fl_Text_Buffer const *)arg1)->highlight_selection();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_prev_char",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_prev_char" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_prev_char" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->prev_char(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_prev_char_clipped(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_prev_char_clipped",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_prev_char_clipped" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->prev_char_clipped(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_next_char(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_next_char",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_next_char" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_next_char" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->next_char(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_next_char_clipped(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_next_char_clipped",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_next_char_clipped" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->next_char_clipped(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_utf8_align(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_utf8_align",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_utf8_align" "', argument " "1"" of type '" "Fl_Text_Buffer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Buffer_utf8_align" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Buffer const *)arg1)->utf8_align(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_modify_callback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_add_modify_callback",2,3,&obj0,&obj1,&obj2)) 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_add_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  if (obj2) {
    arg3 = obj2;
  }
  Fl_Text_Buffer_add_modify_callback__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_add_modify_callback(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_Text_Buffer_add_modify_callback__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Buffer_remove_modify_callback",4,4,&obj0,&obj1,&obj2,&obj3)) 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_remove_modify_callback" "', argument " "1"" of type '" "Fl_Text_Buffer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Buffer * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  arg3 = obj2;
  arg4 = obj3;
  Fl_Text_Buffer_remove_modify_callback__SWIG_1(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Buffer_remove_modify_callback(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_Text_Buffer_remove_modify_callback__SWIG_0(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_Text_Buffer_remove_modify_callback__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Text_Buffer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Style_Table_Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Style_Table_Entry *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Style_Table_Entry",0,0)) SWIG_fail;
  result = (Style_Table_Entry *)new Style_Table_Entry();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Style_Table_Entry *arg1 = (Style_Table_Entry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Style_Table_Entry",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Style_Table_Entry * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Style_Table_Entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Style_Table_Entry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Text_Display(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Text_Display *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Text_Display",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Text_Display" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Text_Display" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Text_Display" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Text_Display" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Text_Display",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Text_Display::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_buffer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_buffer",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Buffer * >(argp2);
  (arg1)->buffer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_buffer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Text_Buffer *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_buffer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Text_Buffer *)((Fl_Text_Display const *)arg1)->buffer();
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_buffer__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_buffer__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_redisplay_range(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_redisplay_range",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_redisplay_range" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_redisplay_range" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->redisplay_range(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scroll(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_scroll",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_scroll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_scroll" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->scroll(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_insert",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->insert((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_overstrike(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_overstrike",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->overstrike((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert_position__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_insert_position",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_insert_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->insert_position(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert_position__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_insert_position",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)((Fl_Text_Display const *)arg1)->insert_position();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_insert_position(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_insert_position__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_insert_position__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_position_to_xy",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &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 = reinterpret_cast< int * >(argp4);
  result = (int)((Fl_Text_Display const *)arg1)->position_to_xy(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_in_selection(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_in_selection",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_in_selection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_in_selection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Fl_Text_Display const *)arg1)->in_selection(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_show_insert_position(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_show_insert_position",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  (arg1)->show_insert_position();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_move_right",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)(arg1)->move_right();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_move_left",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)(arg1)->move_left();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_up(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_move_up",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)(arg1)->move_up();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_move_down(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_move_down",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)(arg1)->move_down();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_count_lines(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_count_lines",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_count_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_count_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_count_lines" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)((Fl_Text_Display const *)arg1)->count_lines(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_line_start(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_line_start",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_line_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Display const *)arg1)->line_start(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_line_end(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_line_end",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_line_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_line_end" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)((Fl_Text_Display const *)arg1)->line_end(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_skip_lines(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_skip_lines",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_skip_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_skip_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_skip_lines" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->skip_lines(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_rewind_lines(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_rewind_lines",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_rewind_lines" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_rewind_lines" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->rewind_lines(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_next_word(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_next_word",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  (arg1)->next_word();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_previous_word(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_previous_word",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  (arg1)->previous_word();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_show_cursor(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_show_cursor",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_show_cursor" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  (arg1)->show_cursor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_hide_cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_hide_cursor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  (arg1)->hide_cursor();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_style(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_cursor_style",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_cursor_style" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->cursor_style(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_color__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_cursor_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Color)((Fl_Text_Display const *)arg1)->cursor_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_cursor_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->cursor_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_cursor_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_cursor_color__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_cursor_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_scrollbar_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)((Fl_Text_Display const *)arg1)->scrollbar_width();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_width__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_scrollbar_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_scrollbar_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->scrollbar_width(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_width(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_scrollbar_width__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_scrollbar_width__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_align__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Align result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_scrollbar_align",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Align)((Fl_Text_Display const *)arg1)->scrollbar_align();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_align__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_scrollbar_align",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Align >(val2);
  (arg1)->scrollbar_align(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_scrollbar_align(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_scrollbar_align__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_scrollbar_align__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_word_start",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_word_start" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Display const *)arg1)->word_start(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_word_end(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_word_end",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_word_end" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Display const *)arg1)->word_end(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_position_style(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_position_style",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_position_style" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_position_style" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_position_style" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)((Fl_Text_Display const *)arg1)->position_style(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_shortcut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_shortcut",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)((Fl_Text_Display const *)arg1)->shortcut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_shortcut__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_shortcut",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_shortcut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->shortcut(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_shortcut(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_shortcut__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_shortcut__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Font)((Fl_Text_Display const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Fontsize)((Fl_Text_Display const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Color)((Fl_Text_Display const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_wrapped_column(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_wrapped_column",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_wrapped_column" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_wrapped_column" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Fl_Text_Display const *)arg1)->wrapped_column(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_wrapped_row(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_wrapped_row",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_wrapped_row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Fl_Text_Display const *)arg1)->wrapped_row(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_wrap_mode(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_wrap_mode",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_wrap_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_wrap_mode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->wrap_mode(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Text_Display_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Display_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Text_Display::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_x_to_col(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_x_to_col",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &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 = static_cast< double >(val2);
  result = (double)((Fl_Text_Display const *)arg1)->x_to_col(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_col_to_x(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_col_to_x",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &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 = static_cast< double >(val2);
  result = (double)((Fl_Text_Display const *)arg1)->col_to_x(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_width__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Display_linenumber_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->linenumber_width(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_width__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (int)((Fl_Text_Display const *)arg1)->linenumber_width();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_width(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_linenumber_width__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_linenumber_width__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_font",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Font >(val2);
  (arg1)->linenumber_font(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_font__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_font",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Font)((Fl_Text_Display const *)arg1)->linenumber_font();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_font(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_linenumber_font__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_linenumber_font__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Fontsize >(val2);
  (arg1)->linenumber_size(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Fontsize)((Fl_Text_Display const *)arg1)->linenumber_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_linenumber_size__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_linenumber_size__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_fgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->linenumber_fgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_fgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_fgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Color)((Fl_Text_Display const *)arg1)->linenumber_fgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_fgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_linenumber_fgcolor__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_linenumber_fgcolor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_bgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->linenumber_bgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_bgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_bgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Color)((Fl_Text_Display const *)arg1)->linenumber_bgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_bgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_linenumber_bgcolor__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_linenumber_bgcolor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_align",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Align >(val2);
  (arg1)->linenumber_align(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_align__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Align result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_align",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (Fl_Align)((Fl_Text_Display const *)arg1)->linenumber_align();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_align(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_linenumber_align__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_linenumber_align__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_format",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->linenumber_format((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_format__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_linenumber_format",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  result = (char *)((Fl_Text_Display const *)arg1)->linenumber_format();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_linenumber_format(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Display_linenumber_format__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Display_linenumber_format__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Text_Display *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Text_Display *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Display_highlight_data(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Display_highlight_data",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Display * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Buffer * >(argp2);
  {
    // Check if it is a list
    if (PyList_Check(obj2)) {
      int size = PyList_Size(obj2);
      int i = 0;
      arg3 = (Style_Table_Entry*) malloc((size)*sizeof(Style_Table_Entry));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj2,i);
        if (PyList_Check(o)) {
          int 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(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Text_Display_highlight_data" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_char(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Text_Display_highlight_data" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  arg6 = obj5;
  arg7 = obj6;
  Fl_Text_Display_highlight_data_new(arg1,arg2,(Fl_Text_Display::Style_Table_Entry const *)arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Text_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Display *arg1 = (Fl_Text_Display *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Text_Display",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Text_Display, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Text_Editor(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Text_Editor *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Text_Editor",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Text_Editor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Text_Editor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Text_Editor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Text_Editor" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Text_Editor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Text_Editor::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_insert_mode__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_insert_mode",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Text_Editor_insert_mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->insert_mode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_insert_mode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_insert_mode",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  result = (int)(arg1)->insert_mode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_insert_mode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Text_Editor_insert_mode__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Text_Editor_insert_mode__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_add_key_binding(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_add_key_binding",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &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 = static_cast< int >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(obj3, (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""'"); 
    }
  }
  (arg1)->add_key_binding(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_remove_key_binding(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_remove_key_binding",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &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 = static_cast< int >(val3);
  (arg1)->remove_key_binding(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_remove_all_key_bindings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_remove_all_key_bindings",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  (arg1)->remove_all_key_bindings();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_bound_key_function(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Text_Editor::Key_Func result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_bound_key_function",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &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 = static_cast< int >(val3);
  result = (Fl_Text_Editor::Key_Func)(arg1)->bound_key_function(arg2,arg3);
  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_default_key_function(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_default_key_function",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Text_Editor * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (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""'"); 
    }
  }
  (arg1)->default_key_function(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_default(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_default",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_default" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_default(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_ignore(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_ignore",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_ignore" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_ignore(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_backspace(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_backspace",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_backspace" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_backspace(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_enter(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_enter",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_enter" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_enter(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_move",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_move" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_move(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_shift_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_shift_move",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_shift_move(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_ctrl_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_ctrl_move",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_ctrl_move(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_c_s_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_c_s_move",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_c_s_move(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_meta_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_meta_move",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_meta_move(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_m_s_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_m_s_move",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_m_s_move(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_home(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_home",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_home" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_home(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_end(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_end",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_end" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_end(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_left(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_left",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_left" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_left(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_up(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_up",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_up" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_up(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_right(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_right",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_right" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_right(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_down(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_down",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_down" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_down(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_page_up(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_page_up",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_page_up(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_page_down(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_page_down",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_page_down(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_insert",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_insert" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_insert(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_delete(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_delete",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_delete" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_delete(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_copy(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_copy",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_copy" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_copy(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_cut(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_cut",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_cut" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_cut(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_paste(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_paste",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_paste" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_paste(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_select_all(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_select_all",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &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 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_select_all(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Text_Editor_kf_undo(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_kf_undo",2,2,&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Text_Editor_kf_undo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Text_Editor * >(argp2);
  result = (int)Fl_Text_Editor::kf_undo(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Text_Editor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Text_Editor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Text_Editor *arg1 = (Fl_Text_Editor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Text_Editor *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Text_Editor_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Text_Editor *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Text_Editor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Tile_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tile_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tile * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Tile::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tile(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Tile *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tile",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Tile" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Tile" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_Fl_Tile_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tile_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tile * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tile_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tile_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Tile::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tile_position(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tile_position",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Tile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Tile_position" "', argument " "1"" of type '" "Fl_Tile *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Tile * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tile_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tile_position" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tile_position" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tile_position" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->position(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Tile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tile",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tile * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Tile",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tile *arg1 = (Fl_Tile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Tile *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tile_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Tile *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tile, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Tiled_Image(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Tiled_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tiled_Image",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tiled_Image" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tiled_Image" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tiled_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tiled_Image_copy",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tiled_Image_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (Fl_Image *)(arg1)->Fl_Tiled_Image::copy(arg2,arg3);
    } else {
      result = (Fl_Image *)(arg1)->copy(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tiled_Image_copy",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  result = (Fl_Image *)(arg1)->copy();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tiled_Image_copy__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Tiled_Image_copy__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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)\n"
    "    Fl_Tiled_Image::copy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_color_average(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tiled_Image_color_average",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_color_average" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Tiled_Image::color_average(arg2,arg3);
    } else {
      (arg1)->color_average(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_desaturate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tiled_Image_desaturate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Tiled_Image::desaturate();
    } else {
      (arg1)->desaturate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_draw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tiled_Image_draw",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tiled_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tiled_Image_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tiled_Image_draw" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tiled_Image_draw" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Tiled_Image_draw" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_draw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tiled_Image_draw",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tiled_Image_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tiled_Image_draw" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->draw(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tiled_Image_draw(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[8];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_Tiled_Image_draw__SWIG_1(self, args);
  }
  if (argc == 7) {
    return _wrap_Fl_Tiled_Image_draw__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tiled_Image_image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tiled_Image * >(argp1);
  result = (Fl_Image *)(arg1)->image();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tiled_Image *arg1 = (Fl_Tiled_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Tiled_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tiled_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Timer_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Timer *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_draw" "', argument " "1"" of type '" "Fl_Timer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Timer *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_handle" "', argument " "1"" of type '" "Fl_Timer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Timer_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Timer::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Fl_Timer *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Timer",7,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Timer" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Timer" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Timer" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Timer" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fl_Timer" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Fl_Timer" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = reinterpret_cast< char * >(buf7);
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Fl_Timer *)new SwigDirector_Fl_Timer(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
  } else {
    result = (Fl_Timer *)new Fl_Timer(arg2,arg3,arg4,arg5,arg6,(char const *)arg7); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Timer, SWIG_POINTER_NEW |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Timer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fl_Timer" "', argument " "1"" of type '" "Fl_Timer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_value" "', argument " "1"" of type '" "Fl_Timer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Timer_value" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_value__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_value" "', argument " "1"" of type '" "Fl_Timer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  result = (double)((Fl_Timer const *)arg1)->value();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Timer_value__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Timer_value__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Timer_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Timer::value(double)\n"
    "    Fl_Timer::value() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_direction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_direction",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_direction" "', argument " "1"" of type '" "Fl_Timer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  result = (char)((Fl_Timer const *)arg1)->direction();
  resultobj = SWIG_NewPointerObj((new char(static_cast< const char& >(result))), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_direction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_direction",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_direction" "', argument " "1"" of type '" "Fl_Timer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Timer_direction" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->direction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_direction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Timer_direction__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Timer_direction__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Timer_direction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Timer::direction() const\n"
    "    Fl_Timer::direction(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_suspended__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_suspended",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_suspended" "', argument " "1"" of type '" "Fl_Timer const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  result = (char)((Fl_Timer const *)arg1)->suspended();
  resultobj = SWIG_NewPointerObj((new char(static_cast< const char& >(result))), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_suspended__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Timer_suspended",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Timer_suspended" "', argument " "1"" of type '" "Fl_Timer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Timer_suspended" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->suspended(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Timer_suspended(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Timer_suspended__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Timer_suspended__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Timer_suspended'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Timer::suspended() const\n"
    "    Fl_Timer::suspended(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Timer *arg1 = (Fl_Timer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Timer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Timer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Fl_Timer" "', argument " "1"" of type '" "Fl_Timer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Timer * >(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_Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Timer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Toggle_Button(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Toggle_Button *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Toggle_Button",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Toggle_Button" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Toggle_Button" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Toggle_Button" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Toggle_Button" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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_delete_Fl_Toggle_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Toggle_Button *arg1 = (Fl_Toggle_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Toggle_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Toggle_Button * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Toggle_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Toggle_Button *arg1 = (Fl_Toggle_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Toggle_Button",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Toggle_Button *arg1 = (Fl_Toggle_Button *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Toggle_Button *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Toggle_Button_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Toggle_Button *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Toggle_Button, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Tooltip_delay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_delay",0,0)) SWIG_fail;
  result = (float)Fl_Tooltip::delay();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_delay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_delay",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_delay" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  Fl_Tooltip::delay(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_delay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Tooltip_delay__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tooltip_delay__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_hoverdelay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  float result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_hoverdelay",0,0)) SWIG_fail;
  result = (float)Fl_Tooltip::hoverdelay();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hoverdelay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_hoverdelay",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_hoverdelay" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  Fl_Tooltip::hoverdelay(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_hoverdelay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Tooltip_hoverdelay__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tooltip_hoverdelay__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_enabled",0,0)) SWIG_fail;
  result = (int)Fl_Tooltip::enabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) 1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_enable",0,1,&obj0)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_int(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_enable" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  Fl_Tooltip::enable(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_disable",0,0)) SWIG_fail;
  Fl_Tooltip::disable();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_enter_area(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_enter_area",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tooltip_enter_area" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tooltip_enter_area" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tooltip_enter_area" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tooltip_enter_area" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  Fl_Tooltip::enter_area(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_current__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_current",0,0)) SWIG_fail;
  result = (Fl_Widget *)Fl_Tooltip::current();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Widget *arg1 = (Fl_Widget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_current",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  Fl_Tooltip::current(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_current(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Tooltip_current__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tooltip_current__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_font",0,0)) SWIG_fail;
  result = (Fl_Font)Fl_Tooltip::font();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_font__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Font arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_font",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_font" "', argument " "1"" of type '" "Fl_Font""'");
  } 
  arg1 = static_cast< Fl_Font >(val1);
  Fl_Tooltip::font(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_font(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Tooltip_font__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tooltip_font__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_size",0,0)) SWIG_fail;
  result = (Fl_Fontsize)Fl_Tooltip::size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_size__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Fontsize arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_size",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_size" "', argument " "1"" of type '" "Fl_Fontsize""'");
  } 
  arg1 = static_cast< Fl_Fontsize >(val1);
  Fl_Tooltip::size(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Tooltip_size__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tooltip_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_color",0,0)) SWIG_fail;
  result = (Fl_Color)Fl_Tooltip::color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_color",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_color" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  Fl_Tooltip::color(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Tooltip_color__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tooltip_color__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_textcolor",0,0)) SWIG_fail;
  result = (Fl_Color)Fl_Tooltip::textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Color arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_textcolor",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Fl_Tooltip_textcolor" "', argument " "1"" of type '" "Fl_Color""'");
  } 
  arg1 = static_cast< Fl_Color >(val1);
  Fl_Tooltip::textcolor(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_Fl_Tooltip_textcolor__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tooltip_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_margin_width",0,0)) SWIG_fail;
  result = (int)Fl_Tooltip::margin_width();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_margin_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_margin_height",0,0)) SWIG_fail;
  result = (int)Fl_Tooltip::margin_height();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tooltip_wrap_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tooltip_wrap_width",0,0)) SWIG_fail;
  result = (int)Fl_Tooltip::wrap_width();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tooltip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tooltip *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tooltip",0,0)) SWIG_fail;
  result = (Fl_Tooltip *)new Fl_Tooltip();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tooltip *arg1 = (Fl_Tooltip *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tooltip",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tooltip * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Tooltip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tooltip, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Value_Output_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Value_Output *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Value_Output *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Value_Output::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Value_Output(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Value_Output *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Value_Output",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Value_Output" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Value_Output" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Value_Output" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Value_Output" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_soft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_soft" "', argument " "2"" of type '" "uchar""'");
  } 
  arg2 = static_cast< uchar >(val2);
  (arg1)->soft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_soft__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  uchar result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_soft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  result = (uchar)((Fl_Value_Output const *)arg1)->soft();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_soft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Output_soft__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Output_soft__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_textfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  result = (Fl_Font)((Fl_Value_Output const *)arg1)->textfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_textfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_textfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->textfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Output_textfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Output_textfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_textsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  result = (Fl_Fontsize)((Fl_Value_Output const *)arg1)->textsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_textsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_textsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->textsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Output_textsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Output_textsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_textcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  result = (Fl_Color)((Fl_Value_Output const *)arg1)->textcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Value_Output_textcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Value_Output_textcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->textcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Value_Output_textcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Value_Output_textcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Value_Output_textcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Value_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Value_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Value_Output * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Value_Output(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Value_Output *arg1 = (Fl_Value_Output *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Value_Output",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Value_Output, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Wizard(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Wizard *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Wizard",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Wizard" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Wizard" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Wizard" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Wizard" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Wizard_next",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Wizard * >(argp1);
  (arg1)->next();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_prev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Wizard_prev",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Wizard * >(argp1);
  (arg1)->prev();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_value__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Wizard_value",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Wizard * >(argp1);
  result = (Fl_Widget *)(arg1)->value();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Wizard_value",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Wizard * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->value(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Wizard_value(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Wizard_value__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Wizard_value__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Wizard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Wizard",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Wizard * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Wizard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Wizard",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *_wrap_Fl_Wizard_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Wizard *arg1 = (Fl_Wizard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Wizard *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Wizard_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Wizard *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Wizard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Wizard, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_XBM_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_XBM_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_XBM_Image",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XBM_Image *arg1 = (Fl_XBM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_XBM_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_XBM_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_XBM_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XBM_Image *arg1 = (Fl_XBM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_XBM_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_XBM_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_XPM_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_XPM_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_XPM_Image",2,2,&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XPM_Image *arg1 = (Fl_XPM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_XPM_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_XPM_Image * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_XPM_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_XPM_Image *arg1 = (Fl_XPM_Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_XPM_Image",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_XPM_Image, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Tree_Prefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tree_Prefs",0,0)) SWIG_fail;
  result = (Fl_Tree_Prefs *)new Fl_Tree_Prefs();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Tree_Prefs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfont__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Font)((Fl_Tree_Prefs const *)arg1)->item_labelfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Font >(val2);
  (arg1)->item_labelfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_item_labelfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_item_labelfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Fontsize)((Fl_Tree_Prefs const *)arg1)->item_labelsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Fontsize >(val2);
  (arg1)->item_labelsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_item_labelsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_item_labelsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelfgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->item_labelfgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelfgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->item_labelfgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelfgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_item_labelfgcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_item_labelfgcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelbgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->item_labelbgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelbgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_item_labelbgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->item_labelbgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_item_labelbgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_item_labelbgcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_item_labelbgcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Font)((Fl_Tree_Prefs const *)arg1)->labelfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->labelfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_labelfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_labelfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Fontsize)((Fl_Tree_Prefs const *)arg1)->labelsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->labelsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_labelsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_labelsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelfgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->labelfgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelfgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->labelfgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelfgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_labelfgcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_labelfgcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelbgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->labelbgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelbgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelbgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->labelbgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelbgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_labelbgcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_labelbgcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_marginleft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->marginleft();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginleft__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_marginleft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_marginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->marginleft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_marginleft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_marginleft__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_marginleft__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_margintop",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->margintop();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_margintop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_margintop",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_margintop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->margintop(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_margintop(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_margintop__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_margintop__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_openchild_marginbottom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_openchild_marginbottom",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->openchild_marginbottom();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openchild_marginbottom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_openchild_marginbottom",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_openchild_marginbottom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->openchild_marginbottom(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openchild_marginbottom(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_openchild_marginbottom__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_openchild_marginbottom__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_usericonmarginleft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->usericonmarginleft();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericonmarginleft__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_usericonmarginleft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_usericonmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->usericonmarginleft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericonmarginleft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_usericonmarginleft__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_usericonmarginleft__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelmarginleft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->labelmarginleft();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelmarginleft__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_labelmarginleft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_labelmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->labelmarginleft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_labelmarginleft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_labelmarginleft__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_labelmarginleft__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_linespacing__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_linespacing",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->linespacing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_linespacing__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_linespacing",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_linespacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->linespacing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_linespacing(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_linespacing__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_linespacing__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_connectorcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Color)((Fl_Tree_Prefs const *)arg1)->connectorcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_connectorcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_connectorcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->connectorcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_connectorcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_connectorcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Connector result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_connectorstyle",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Tree_Connector)((Fl_Tree_Prefs const *)arg1)->connectorstyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorstyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_connectorstyle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Tree_Connector >(val2);
  (arg1)->connectorstyle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorstyle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_connectorstyle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_connectorstyle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->connectorstyle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorstyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_connectorstyle__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_connectorstyle__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_connectorstyle__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_connectorwidth",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->connectorwidth();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorwidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_connectorwidth",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_connectorwidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->connectorwidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_connectorwidth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_connectorwidth__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_connectorwidth__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_openicon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->openicon();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_openicon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->openicon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_openicon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_openicon__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_openicon__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_closeicon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->closeicon();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_closeicon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->closeicon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_closeicon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_closeicon__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_closeicon__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_usericon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Image *)((Fl_Tree_Prefs const *)arg1)->usericon();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_usericon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->usericon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_usericon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_usericon__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_usericon__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_showcollapse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_showcollapse",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (char)((Fl_Tree_Prefs const *)arg1)->showcollapse();
  resultobj = SWIG_NewPointerObj((new char(static_cast< const char& >(result))), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showcollapse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_showcollapse",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_showcollapse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->showcollapse(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showcollapse(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_showcollapse__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_showcollapse__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Sort result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_sortorder",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Tree_Sort)((Fl_Tree_Prefs const *)arg1)->sortorder();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_sortorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_sortorder",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Tree_Sort >(val2);
  (arg1)->sortorder(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_sortorder(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_sortorder__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_sortorder__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_selectbox",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Boxtype)((Fl_Tree_Prefs const *)arg1)->selectbox();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectbox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_selectbox",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_selectbox" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  (arg1)->selectbox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectbox(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_selectbox__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_selectbox__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_showroot",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (int)((Fl_Tree_Prefs const *)arg1)->showroot();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showroot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_showroot",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Prefs_showroot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->showroot(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_showroot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_showroot__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_showroot__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Select result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_selectmode",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Tree_Select)((Fl_Tree_Prefs const *)arg1)->selectmode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectmode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Prefs_selectmode",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Tree_Select >(val2);
  (arg1)->selectmode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Prefs_selectmode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Prefs_selectmode__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Prefs_selectmode__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_delete_Fl_Tree_Prefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = (Fl_Tree_Prefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tree_Prefs",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Tree_Prefs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tree_Prefs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item_Array__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 = (int) 10 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item_Array *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tree_Item_Array",0,1,&obj0)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_int(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fl_Tree_Item_Array" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  result = (Fl_Tree_Item_Array *)new Fl_Tree_Item_Array(arg1);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tree_Item_Array",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item_Array__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item_Array *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tree_Item_Array",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  result = (Fl_Tree_Item_Array *)new Fl_Tree_Item_Array((Fl_Tree_Item_Array const *)arg1);
  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) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 1) {
    return _wrap_new_Fl_Tree_Item_Array__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_total",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  result = (int)((Fl_Tree_Item_Array const *)arg1)->total();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_swap(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_swap",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_swap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_Array_swap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->swap(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_move(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_move",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_move" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_Array_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->move(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_deparent(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_deparent",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_deparent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->deparent(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_reparent(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_reparent",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Tree_Item * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_Array_reparent" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)(arg1)->reparent(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item_Array *arg1 = (Fl_Tree_Item_Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_add(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_insert",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Tree_Item * >(argp3);
  (arg1)->insert(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_replace(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_replace",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Tree_Item * >(argp3);
  (arg1)->replace(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_Array_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_Array_remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item_Array * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)(arg1)->remove(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_Array_remove(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_Array_remove__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *Fl_Tree_Item_Array_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tree_Item_Array, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Prefs *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tree_Item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Tree_Item" "', argument " "1"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fl_Tree_Item" "', argument " "1"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg1 = reinterpret_cast< Fl_Tree_Prefs * >(argp1);
  result = (Fl_Tree_Item *)new Fl_Tree_Item((Fl_Tree_Prefs const &)*arg1);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tree_Item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Tree_Item__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tree_Item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fl_Tree_Item" "', argument " "1"" of type '" "Fl_Tree_Item const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Tree_Item *)new Fl_Tree_Item((Fl_Tree_Item const *)arg1);
  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) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Fl_Tree_Prefs, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_Fl_Tree_Item__SWIG_0(self, args);
  }
check_1:
  
  if (argc == 1) {
    return _wrap_new_Fl_Tree_Item__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_Item const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_x",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->x();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_y",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->y();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_w",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_h",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_label_x",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->label_x();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_label_y",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->label_y();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_label_w",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->label_w();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label_h(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_label_h",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->label_h();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int arg4 ;
  Fl_Widget *arg5 = (Fl_Widget *) 0 ;
  Fl_Tree_Item *arg6 = (Fl_Tree_Item *) 0 ;
  Fl_Tree_Prefs *arg7 = 0 ;
  int arg8 = (int) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int temp3 ;
  int res3 = SWIG_TMPOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_draw",6,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_draw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode4 = SWIG_AsVal_int(obj2, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_draw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Tree_Item_draw" "', argument " "5"" of type '" "Fl_Widget *""'"); 
  }
  arg5 = reinterpret_cast< Fl_Widget * >(argp5);
  res6 = SWIG_ConvertPtr(obj4, &argp6,SWIGTYPE_p_Fl_Tree_Item, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Fl_Tree_Item_draw" "', argument " "6"" of type '" "Fl_Tree_Item *""'"); 
  }
  arg6 = reinterpret_cast< Fl_Tree_Item * >(argp6);
  res7 = SWIG_ConvertPtr(obj5, &argp7, SWIGTYPE_p_Fl_Tree_Prefs,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Fl_Tree_Item_draw" "', argument " "7"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_draw" "', argument " "7"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg7 = reinterpret_cast< Fl_Tree_Prefs * >(argp7);
  if (obj6) {
    ecode8 = SWIG_AsVal_int(obj6, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Tree_Item_draw" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< int >(val8);
  }
  (arg1)->draw(arg2,*arg3,arg4,arg5,arg6,(Fl_Tree_Prefs const &)*arg7,arg8);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_show_self(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_show_self",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  if (obj1) {
    res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  }
  ((Fl_Tree_Item const *)arg1)->show_self((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_label",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (char *)((Fl_Tree_Item const *)arg1)->label();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_label(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_label__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_label__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_user_data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_user_data",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Tree_Item_user_data" "', argument " "2"" of type '" "void *""'"); 
  }
  (arg1)->user_data(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_user_data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  void *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_user_data",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 const *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (void *)((Fl_Tree_Item const *)arg1)->user_data();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_user_data(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_user_data__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_user_data__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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(void *)\n"
    "    Fl_Tree_Item::user_data() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfont__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->labelfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Font)((Fl_Tree_Item const *)arg1)->labelfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_labelfont__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_labelfont__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->labelsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Fontsize)((Fl_Tree_Item const *)arg1)->labelsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_labelsize__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_labelsize__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelfgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->labelfgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelfgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Color)((Fl_Tree_Item const *)arg1)->labelfgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelfgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_labelfgcolor__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_labelfgcolor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->labelcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Color)((Fl_Tree_Item const *)arg1)->labelcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_labelcolor__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_labelcolor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelbgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_labelbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->labelbgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelbgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_labelbgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Color)((Fl_Tree_Item const *)arg1)->labelbgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_labelbgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_labelbgcolor__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_labelbgcolor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_widget",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->widget(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_widget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_widget",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Widget *)((Fl_Tree_Item const *)arg1)->widget();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_widget__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_widget__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_children",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->children();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_child__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Fl_Tree_Item *)(arg1)->child(arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->child(arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_child__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_child__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_has_children",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->has_children();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->find_child((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)(arg1)->find_child(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_find_child(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_find_child__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_remove_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)(arg1)->remove_child(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_remove_child__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_remove_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->remove_child((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_remove_child(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_remove_child__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_clear_children",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  (arg1)->clear_children();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_swap_children__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_swap_children",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_swap_children" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_swap_children" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->swap_children(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_swap_children__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_swap_children",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Tree_Item * >(argp3);
  result = (int)(arg1)->swap_children(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_swap_children(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_Tree_Item_swap_children__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_child_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_child_item((char const *)arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_child_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (Fl_Tree_Item *)(arg1)->find_child_item((char const *)arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_child_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
          arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_child_item(arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_child_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
          arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  result = (Fl_Tree_Item *)(arg1)->find_child_item(arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
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, args);
  }
check_2:
  
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_find_child_item__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_find_child_item__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
          arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_item(arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  {
    /* Check if it is a list */
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
          arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  result = (Fl_Tree_Item *)(arg1)->find_item(arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_find_item__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_find_item__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_add",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(obj3, &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 = reinterpret_cast< Fl_Tree_Item * >(argp4);
  result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,(char const *)arg3,arg4);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_add",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,(char const *)arg3);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_add",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  {
    /* Check if it is a list */
    if (PyList_Check(obj2)) {
      int size = PyList_Size(obj2);
      int i = 0;
      arg3 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj2,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg3[i] = PyString_AsString(PyList_GetItem(obj2,i));
          arg3[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj2,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(obj3, &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 = reinterpret_cast< Fl_Tree_Item * >(argp4);
  result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,arg3,arg4);
  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 *SWIGUNUSEDPARM(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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_add",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_add" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  {
    /* Check if it is a list */
    if (PyList_Check(obj2)) {
      int size = PyList_Size(obj2);
      int i = 0;
      arg3 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj2,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg3[i] = PyString_AsString(PyList_GetItem(obj2,i));
          arg3[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj2,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;
    }
  }
  result = (Fl_Tree_Item *)(arg1)->add((Fl_Tree_Prefs const &)*arg2,arg3);
  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) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_Tree_Item_add__SWIG_1(self, args);
  }
  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;
    return _wrap_Fl_Tree_Item_add__SWIG_2(self, args);
  }
check_3:
  
  if (argc == 4) {
    return _wrap_Fl_Tree_Item_add__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_insert",3,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_insert" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_insert" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  result = (Fl_Tree_Item *)(arg1)->insert((Fl_Tree_Prefs const &)*arg2,(char const *)arg3,arg4);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_insert_above",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_insert_above" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (Fl_Tree_Item *)(arg1)->insert_above((Fl_Tree_Prefs const &)*arg2,(char const *)arg3);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_deparent",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_deparent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Fl_Tree_Item *)(arg1)->deparent(arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_reparent",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_reparent" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->reparent(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_move",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_move" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->move(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move__SWIG_1(PyObject *SWIGUNUSEDPARM(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 ;
  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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_move",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_move" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_Item_move" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  result = (int)(arg1)->move(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Tree_Item_move__SWIG_1(self, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_Tree_Item_move__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_move_above",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)(arg1)->move_above(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move_below(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_move_below",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)(arg1)->move_below(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_move_into(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_move_into",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_Item_move_into" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->move_into(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_depth",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->depth();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_prev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_prev",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->prev();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_next",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->next();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_next_sibling",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->next_sibling();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_prev_sibling",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->prev_sibling();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_update_prev_next",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  (arg1)->update_prev_next(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_next_displayed(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_next_displayed",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_next_displayed" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (Fl_Tree_Item *)(arg1)->next_displayed(*arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_prev_displayed",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_prev_displayed" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (Fl_Tree_Item *)(arg1)->prev_displayed(*arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_next_visible",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_next_visible" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (Fl_Tree_Item *)(arg1)->next_visible(*arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_prev_visible",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_prev_visible" "', argument " "2"" of type '" "Fl_Tree_Prefs &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (Fl_Tree_Item *)(arg1)->prev_visible(*arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_parent",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->parent();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_parent",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->parent();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_parent",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->parent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_parent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_parent__SWIG_0(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_parent__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_parent__SWIG_2(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_open",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  (arg1)->open();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_close",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  (arg1)->close();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_is_open",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->is_open();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_is_close",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->is_close();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_open_toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_open_toggle",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  (arg1)->open_toggle();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_select(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_select",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_select" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  (arg1)->select(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_select_toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_select_toggle",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  (arg1)->select_toggle();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_select_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_select_all",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)(arg1)->select_all();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_deselect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_deselect",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  (arg1)->deselect();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_deselect_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_deselect_all",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)(arg1)->deselect_all();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_selected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_is_selected",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (char)((Fl_Tree_Item const *)arg1)->is_selected();
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_activate(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_activate",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_Item_activate" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  (arg1)->activate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_deactivate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_deactivate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  (arg1)->deactivate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_activated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_is_activated",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (char)((Fl_Tree_Item const *)arg1)->is_activated();
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_active(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_is_active",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (char)((Fl_Tree_Item const *)arg1)->is_active();
  {
    resultobj = PyInt_FromLong( (long)result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_visible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->visible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_visible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_is_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->is_visible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_visible_r(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_visible_r",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->visible_r();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_usericon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_usericon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->usericon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_usericon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_usericon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (Fl_Image *)((Fl_Tree_Item const *)arg1)->usericon();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_Item_usericon__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_usericon__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_find_clicked__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_clicked",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_find_clicked" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (Fl_Tree_Item *)((Fl_Tree_Item const *)arg1)->find_clicked((Fl_Tree_Prefs const &)*arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_find_clicked",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_find_clicked" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (Fl_Tree_Item *)(arg1)->find_clicked((Fl_Tree_Prefs const &)*arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_find_clicked__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_Item_find_clicked__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 &) const\n"
    "    Fl_Tree_Item::find_clicked(Fl_Tree_Prefs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_event_on_collapse_icon(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_event_on_collapse_icon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_event_on_collapse_icon" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (int)((Fl_Tree_Item const *)arg1)->event_on_collapse_icon((Fl_Tree_Prefs const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_event_on_label(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_event_on_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_Item_event_on_label" "', argument " "2"" of type '" "Fl_Tree_Prefs const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Tree_Prefs * >(argp2);
  result = (int)((Fl_Tree_Item const *)arg1)->event_on_label((Fl_Tree_Prefs const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_Item_is_root(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree_Item *arg1 = (Fl_Tree_Item *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_Item_is_root",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree_Item * >(argp1);
  result = (int)((Fl_Tree_Item const *)arg1)->is_root();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Tree_Item_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tree_Item, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Tree(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Tree *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Tree",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Tree" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Tree" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Tree" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Tree" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Tree",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Tree::handle(arg2);
    } else {
      result = (int)(arg1)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Tree::draw();
    } else {
      (arg1)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_self(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_show_self",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  (arg1)->show_self();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_resize(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tree_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Tree::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_root_label(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_root_label",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  (arg1)->root_label((char const *)arg2);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_root__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_root",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->root();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_root",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->root(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_root(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_root__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_root__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Prefs *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_prefs",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Prefs *) &((Fl_Tree const *)arg1)->prefs();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (Fl_Tree_Item *)(arg1)->add((char const *)arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_add",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Tree_Item * >(argp3);
  result = (Fl_Tree_Item *)(arg1)->add((char const *)arg2,arg3);
  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_2(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_add",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (Fl_Tree_Item *)(arg1)->add(arg2,(char const *)arg3);
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_add__SWIG_0(self, args);
  }
  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_2;
    {
      int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Fl_Tree_add__SWIG_2(self, args);
  }
check_2:
  
  if (argc == 3) {
    return _wrap_Fl_Tree_add__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Tree_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::add(char const *)\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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_insert_above",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  result = (Fl_Tree_Item *)(arg1)->insert_above(arg2,(char const *)arg3);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_insert",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_insert" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Fl_Tree_Item *)(arg1)->insert(arg2,(char const *)arg3,arg4);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_remove",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)(arg1)->remove(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_clear_children(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_clear_children",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->clear_children(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_item__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_find_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (Fl_Tree_Item *)(arg1)->find_item((char const *)arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_find_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (Fl_Tree_Item *)((Fl_Tree const *)arg1)->find_item((char const *)arg2);
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_find_item__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_find_item__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_pathname",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_item_pathname" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &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 = reinterpret_cast< Fl_Tree_Item * >(argp4);
  result = (int)((Fl_Tree const *)arg1)->item_pathname(arg2,arg3,(Fl_Tree_Item const *)arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_find_clicked__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_find_clicked",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)((Fl_Tree const *)arg1)->find_clicked();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_find_clicked",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->find_clicked();
  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) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_find_clicked__SWIG_1(self, args);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_find_clicked__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Tree_find_clicked'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::find_clicked() const\n"
    "    Fl_Tree::find_clicked()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_clicked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_clicked",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->item_clicked();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_first",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->first();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_first_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->first_visible();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_first_visible_item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->first_visible_item();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_next",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  }
  result = (Fl_Tree_Item *)(arg1)->next(arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_prev",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  }
  result = (Fl_Tree_Item *)(arg1)->prev(arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_last",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->last();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_last_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->last_visible();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_last_visible_item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->last_visible_item();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_first_selected_item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->first_selected_item();
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_last_selected_item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->last_selected_item();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_next_item",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_next_item" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_next_item" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  result = (Fl_Tree_Item *)(arg1)->next_item(arg2,arg3,arg4);
  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__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_next_selected_item",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  }
  result = (Fl_Tree_Item *)(arg1)->next_selected_item(arg2);
  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__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_next_selected_item",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_next_selected_item" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Fl_Tree_Item *)(arg1)->next_selected_item(arg2,arg3);
  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) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if ((argc >= 1) && (argc <= 2)) {
    return _wrap_Fl_Tree_next_selected_item__SWIG_0(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Tree_next_selected_item__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Tree_next_selected_item'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Tree::next_selected_item(Fl_Tree_Item *)\n"
    "    Fl_Tree::next_selected_item(Fl_Tree_Item *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_open__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_open",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_open" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->open(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_open__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_open",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_open" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->open((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_open(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Tree_open__SWIG_0(self, args);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_Fl_Tree_open__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_open_toggle",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_open_toggle" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  (arg1)->open_toggle(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_close__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_close",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_close" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->close(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_close__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_close",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_close" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->close((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_close(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Tree_close__SWIG_0(self, args);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_Fl_Tree_close__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_open",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)((Fl_Tree const *)arg1)->is_open(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_open__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_open",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)((Fl_Tree const *)arg1)->is_open((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_open(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Tree_is_open__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_close",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)((Fl_Tree const *)arg1)->is_close(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_close__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_close",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)((Fl_Tree const *)arg1)->is_close((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_close(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Tree_is_close__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_select",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->select(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_select",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->select((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Tree_select__SWIG_0(self, args);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_Fl_Tree_select__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_select_toggle",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select_toggle" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  (arg1)->select_toggle(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_deselect__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_deselect",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_deselect" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->deselect(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_deselect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_deselect",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_deselect" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->deselect((char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_deselect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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;
    return _wrap_Fl_Tree_deselect__SWIG_0(self, args);
  }
check_1:
  
  if ((argc >= 2) && (argc <= 3)) {
    return _wrap_Fl_Tree_deselect__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_deselect_all",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_deselect_all" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->deselect_all(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select_only(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_select_only",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select_only" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->select_only(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_select_all(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_select_all",1,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_select_all" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->select_all(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_extend_selection_dir(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_extend_selection_dir",6,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Tree_Item * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Tree_extend_selection_dir" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (int)(arg1)->extend_selection_dir(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_set_item_focus(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_set_item_focus",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->set_item_focus(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_get_item_focus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_get_item_focus",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)((Fl_Tree const *)arg1)->get_item_focus();
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)((Fl_Tree const *)arg1)->is_selected(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_selected__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->is_selected((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_selected(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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, args);
  }
check_1:
  
  if (argc == 2) {
    return _wrap_Fl_Tree_is_selected__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Font result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelfont",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Font)((Fl_Tree const *)arg1)->item_labelfont();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfont__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Font arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelfont",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelfont" "', argument " "2"" of type '" "Fl_Font""'");
  } 
  arg2 = static_cast< Fl_Font >(val2);
  (arg1)->item_labelfont(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfont(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_item_labelfont__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_item_labelfont__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Fontsize result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelsize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Fontsize)((Fl_Tree const *)arg1)->item_labelsize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelsize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Fontsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelsize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelsize" "', argument " "2"" of type '" "Fl_Fontsize""'");
  } 
  arg2 = static_cast< Fl_Fontsize >(val2);
  (arg1)->item_labelsize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelsize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_item_labelsize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_item_labelsize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelfgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Color)((Fl_Tree const *)arg1)->item_labelfgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelfgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelfgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->item_labelfgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelfgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_item_labelfgcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_item_labelfgcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelbgcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Color)((Fl_Tree const *)arg1)->item_labelbgcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelbgcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_item_labelbgcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_item_labelbgcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->item_labelbgcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_item_labelbgcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_item_labelbgcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_item_labelbgcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_connectorcolor",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Color)((Fl_Tree const *)arg1)->connectorcolor();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorcolor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_connectorcolor",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_connectorcolor" "', argument " "2"" of type '" "Fl_Color""'");
  } 
  arg2 = static_cast< Fl_Color >(val2);
  (arg1)->connectorcolor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorcolor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_connectorcolor__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_connectorcolor__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_marginleft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->marginleft();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginleft__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_marginleft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_marginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->marginleft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_marginleft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_marginleft__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_marginleft__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_margintop",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->margintop();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_margintop__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_margintop",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_margintop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->margintop(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_margintop(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_margintop__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_margintop__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_linespacing__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_linespacing",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->linespacing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_linespacing__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_linespacing",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_linespacing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->linespacing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_linespacing(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_linespacing__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_linespacing__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_openchild_marginbottom",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->openchild_marginbottom();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openchild_marginbottom__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_openchild_marginbottom",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_openchild_marginbottom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->openchild_marginbottom(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openchild_marginbottom(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_openchild_marginbottom__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_openchild_marginbottom__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_usericonmarginleft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->usericonmarginleft();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericonmarginleft__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_usericonmarginleft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_usericonmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->usericonmarginleft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericonmarginleft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_usericonmarginleft__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_usericonmarginleft__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_labelmarginleft",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->labelmarginleft();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_labelmarginleft__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_labelmarginleft",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_labelmarginleft" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->labelmarginleft(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_labelmarginleft(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_labelmarginleft__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_labelmarginleft__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_connectorwidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_connectorwidth",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->connectorwidth();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorwidth__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_connectorwidth",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_connectorwidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->connectorwidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorwidth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_connectorwidth__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_connectorwidth__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_usericon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Image *)((Fl_Tree const *)arg1)->usericon();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_usericon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->usericon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_usericon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_usericon__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_usericon__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_openicon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Image *)((Fl_Tree const *)arg1)->openicon();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_openicon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->openicon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_openicon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_openicon__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_openicon__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Image *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_closeicon",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Image *)((Fl_Tree const *)arg1)->closeicon();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_closeicon",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Image * >(argp2);
  (arg1)->closeicon(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_closeicon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_closeicon__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_closeicon__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_showcollapse",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->showcollapse();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showcollapse__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_showcollapse",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_showcollapse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->showcollapse(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showcollapse(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_showcollapse__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_showcollapse__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_showroot",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->showroot();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showroot__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_showroot",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_showroot" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->showroot(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_showroot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_showroot__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_showroot__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Connector result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_connectorstyle",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Connector)((Fl_Tree const *)arg1)->connectorstyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorstyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Connector arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_connectorstyle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_connectorstyle" "', argument " "2"" of type '" "Fl_Tree_Connector""'");
  } 
  arg2 = static_cast< Fl_Tree_Connector >(val2);
  (arg1)->connectorstyle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_connectorstyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_connectorstyle__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_connectorstyle__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Sort result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_sortorder",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Sort)((Fl_Tree const *)arg1)->sortorder();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_sortorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Sort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_sortorder",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_sortorder" "', argument " "2"" of type '" "Fl_Tree_Sort""'");
  } 
  arg2 = static_cast< Fl_Tree_Sort >(val2);
  (arg1)->sortorder(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_sortorder(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_sortorder__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_sortorder__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_selectbox",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Boxtype)((Fl_Tree const *)arg1)->selectbox();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectbox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Boxtype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_selectbox",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_selectbox" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  (arg1)->selectbox(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectbox(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_selectbox__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_selectbox__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Select result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_selectmode",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Select)((Fl_Tree const *)arg1)->selectmode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectmode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Select arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_selectmode",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_selectmode" "', argument " "2"" of type '" "Fl_Tree_Select""'");
  } 
  arg2 = static_cast< Fl_Tree_Select >(val2);
  (arg1)->selectmode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_selectmode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_selectmode__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_selectmode__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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_recalc_tree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_recalc_tree",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  (arg1)->recalc_tree();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_displayed(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_displayed",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  result = (int)(arg1)->displayed(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_show_item",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Tree_show_item" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->show_item(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_show_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->show_item(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_show_item__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Tree_show_item__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_show_item_top",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->show_item_top(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item_middle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_show_item_middle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->show_item_middle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_show_item_bottom(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_show_item_bottom",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->show_item_bottom(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_display(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_display",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->display(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_vposition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_vposition",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->vposition();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_vposition__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_vposition",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_vposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->vposition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_vposition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_vposition__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_vposition__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_hposition",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->hposition();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_hposition__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_hposition",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_hposition" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->hposition(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_hposition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_hposition__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_hposition__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_scrollbar",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (int)(arg1)->is_scrollbar(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_scrollbar_size__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_scrollbar_size",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->scrollbar_size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_scrollbar_size__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_scrollbar_size",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Tree_scrollbar_size" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->scrollbar_size(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_scrollbar_size(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_scrollbar_size__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_scrollbar_size__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_vscroll_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->is_vscroll_visible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_is_hscroll_visible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_is_hscroll_visible",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (int)((Fl_Tree const *)arg1)->is_hscroll_visible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_item__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_callback_item",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Tree_Item * >(argp2);
  (arg1)->callback_item(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_item__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Item *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_callback_item",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Item *)(arg1)->callback_item();
  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) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_callback_item__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_callback_item__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  Fl_Tree_Reason arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_callback_reason",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Tree_Reason >(val2);
  (arg1)->callback_reason(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_reason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Tree_Reason result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_callback_reason",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  result = (Fl_Tree_Reason)((Fl_Tree const *)arg1)->callback_reason();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Tree_callback_reason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Tree_callback_reason__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Tree_callback_reason__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Tree_load",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Tree_load" "', argument " "2"" of type '" "Fl_Preferences &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Preferences * >(argp2);
  (arg1)->load(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Tree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Tree *arg1 = (Fl_Tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Tree",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Tree, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fl_Paged_Device(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Fl_Paged_Device *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Paged_Device",1,1,&obj0)) SWIG_fail;
  arg1 = obj0;
  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;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Paged_Device, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_class_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_class_name",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_class_name" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  result = (char *)(arg1)->class_name();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_start_job(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  int arg2 ;
  int *arg3 = (int *) NULL ;
  int *arg4 = (int *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_start_job",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_start_job" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< int * >(argp3);
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &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 = reinterpret_cast< int * >(argp4);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Paged_Device::start_job(arg2,arg3,arg4);
    } else {
      result = (int)(arg1)->start_job(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_start_page(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_start_page",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Paged_Device::start_page();
    } else {
      result = (int)(arg1)->start_page();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_printable_rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_printable_rect",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_printable_rect" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Paged_Device_printable_rect" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Paged_Device_printable_rect" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Paged_Device::printable_rect(arg2,arg3);
    } else {
      result = (int)(arg1)->printable_rect(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_margins(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_margins",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &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 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &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 = reinterpret_cast< int * >(argp5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::margins(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->margins(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_origin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_origin",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_origin" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::origin(arg2,arg3);
    } else {
      (arg1)->origin(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_origin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_origin",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_origin" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Paged_Device_origin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Paged_Device_origin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::origin(arg2,arg3);
    } else {
      (arg1)->origin(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_origin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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_Paged_Device_origin__SWIG_1(self, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_Paged_Device_origin__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Fl_Paged_Device_origin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fl_Paged_Device::origin(int,int)\n"
    "    Fl_Paged_Device::origin(int *,int *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_scale(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_scale",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_float(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_scale" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = static_cast< float >(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::scale(arg2,arg3);
    } else {
      (arg1)->scale(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_rotate(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_rotate",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_rotate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::rotate(arg2);
    } else {
      (arg1)->rotate(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_translate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_translate",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_translate" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Paged_Device_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::translate(arg2,arg3);
    } else {
      (arg1)->translate(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_untranslate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_untranslate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Paged_Device, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Paged_Device_untranslate" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::untranslate();
    } else {
      (arg1)->untranslate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_print_widget(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_print_widget",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_print_widget" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Paged_Device_print_widget" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::print_widget(arg2,arg3,arg4);
    } else {
      (arg1)->print_widget(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_print_window(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_print_window",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Window * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_print_window" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Paged_Device_print_window" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  (arg1)->print_window(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_print_window_part(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_print_window_part",6,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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_part" "', argument " "1"" of type '" "Fl_Paged_Device *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Paged_Device_print_window_part" "', argument " "2"" of type '" "Fl_Window *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Window * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Paged_Device_print_window_part" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Paged_Device_print_window_part" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Paged_Device_print_window_part" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Paged_Device_print_window_part" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Paged_Device_print_window_part" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Paged_Device_print_window_part" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< int >(val8);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::print_window_part(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } else {
      (arg1)->print_window_part(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_end_page(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_end_page",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Paged_Device::end_page();
    } else {
      result = (int)(arg1)->end_page();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Paged_Device_end_job(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Paged_Device_end_job",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Paged_Device * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Paged_Device::end_job();
    } else {
      (arg1)->end_job();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Paged_Device(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Paged_Device *arg1 = (Fl_Paged_Device *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Paged_Device",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *Fl_Paged_Device_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Paged_Device, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Printer_class_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_class_name",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_class_name" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Printer * >(argp1);
  result = (char *)(arg1)->class_name();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Printer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Fl_Printer *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Printer",1,1,&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Fl_Printer *)new SwigDirector_Fl_Printer(arg1); 
  } else {
    result = (Fl_Printer *)new Fl_Printer(); 
  }
  
  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_start_job(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  int arg2 ;
  int *arg3 = (int *) NULL ;
  int *arg4 = (int *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_start_job",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_start_job" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Printer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_start_job" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Printer_start_job" "', argument " "3"" of type '" "int *""'"); 
    }
    arg3 = reinterpret_cast< int * >(argp3);
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Printer_start_job" "', argument " "4"" of type '" "int *""'"); 
    }
    arg4 = reinterpret_cast< int * >(argp4);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Printer::start_job(arg2,arg3,arg4);
    } else {
      result = (int)(arg1)->start_job(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_start_page(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_start_page",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_start_page" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Printer * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Printer::start_page();
    } else {
      result = (int)(arg1)->start_page();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_printable_rect(PyObject *SWIGUNUSEDPARM(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 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_printable_rect",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Printer_printable_rect" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Printer_printable_rect" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Printer::printable_rect(arg2,arg3);
    } else {
      result = (int)(arg1)->printable_rect(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_margins(PyObject *SWIGUNUSEDPARM(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 ;
  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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_margins",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Printer_margins" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Printer_margins" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fl_Printer_margins" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Fl_Printer_margins" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::margins(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->margins(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_origin__SWIG_0(PyObject *SWIGUNUSEDPARM(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 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_origin",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Printer_origin" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fl_Printer_origin" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::origin(arg2,arg3);
    } else {
      (arg1)->origin(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_origin__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_origin",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_origin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_origin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::origin(arg2,arg3);
    } else {
      (arg1)->origin(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_origin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  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_Printer_origin__SWIG_0(self, args);
  }
check_1:
  
  if (argc == 3) {
    return _wrap_Fl_Printer_origin__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_scale",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_scale" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_float(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_scale" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = static_cast< float >(val3);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::scale(arg2,arg3);
    } else {
      (arg1)->scale(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_rotate(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_rotate",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_rotate" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::rotate(arg2);
    } else {
      (arg1)->rotate(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_translate(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_translate",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Printer_translate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_translate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::translate(arg2,arg3);
    } else {
      (arg1)->translate(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_untranslate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_untranslate",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::untranslate();
    } else {
      (arg1)->untranslate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_end_page(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_end_page",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Fl_Printer::end_page();
    } else {
      result = (int)(arg1)->end_page();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_end_job(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_end_job",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::end_job();
    } else {
      (arg1)->end_job();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_print_widget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_print_widget",2,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_print_widget" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Printer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Widget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Printer_print_widget" "', argument " "2"" of type '" "Fl_Widget *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_print_widget" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Printer_print_widget" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::print_widget(arg2,arg3,arg4);
    } else {
      (arg1)->print_widget(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_print_window_part(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_print_window_part",6,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_print_window_part" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Printer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Fl_Window, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fl_Printer_print_window_part" "', argument " "2"" of type '" "Fl_Window *""'"); 
  }
  arg2 = reinterpret_cast< Fl_Window * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Printer_print_window_part" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Printer_print_window_part" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Printer_print_window_part" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Printer_print_window_part" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Printer_print_window_part" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Printer_print_window_part" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< int >(val8);
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Printer::print_window_part(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } else {
      (arg1)->print_window_part(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_set_current(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_set_current",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  (arg1)->set_current();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Printer_driver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Graphics_Driver *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Printer_driver",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Fl_Printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fl_Printer_driver" "', argument " "1"" of type '" "Fl_Printer *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Printer * >(argp1);
  result = (Fl_Graphics_Driver *)(arg1)->driver();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Fl_Graphics_Driver, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fl_Printer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Printer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Printer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Printer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Printer *arg1 = (Fl_Printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Printer",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *Fl_Printer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Printer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fl_utf8bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8bytes",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_utf8bytes" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (int)fl_utf8bytes(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8len",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_utf8len" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  result = (int)fl_utf8len(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_nb_char(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf_nb_char",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< unsigned char * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf_nb_char" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)fl_utf_nb_char((unsigned char const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8decode(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8decode",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8decode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf8decode" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< int * >(argp3);
  result = (unsigned int)fl_utf8decode((char const *)arg1,(char const *)arg2,arg3);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8encode(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  int result;
  
  arg2 = &temp2;
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8encode",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_utf8encode" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (int)fl_utf8encode(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_char((*arg2)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8fwd(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8fwd",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8fwd" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf8fwd" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8fwd" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (char *)fl_utf8fwd((char const *)arg1,(char const *)arg2,(char const *)arg3);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8back",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8back" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf8back" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8back" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (char *)fl_utf8back((char const *)arg1,(char const *)arg2,(char const *)arg3);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned int result;
  
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8toUtf16",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8toUtf16" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8toUtf16" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj2, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8toUtf16" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = (unsigned int)fl_utf8toUtf16((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_short((*arg3)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8toa(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  unsigned int result;
  
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8toa",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fl_utf8toa" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8toa" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj2, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8toa" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = (unsigned int)fl_utf8toa((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_char((*arg3)));
  } 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));
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8froma(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8froma",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_utf8froma" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8froma" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8froma" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8froma" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = (unsigned int)fl_utf8froma(arg1,arg2,(char const *)arg3,arg4);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8locale",0,0)) SWIG_fail;
  result = (int)fl_utf8locale();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8test(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8test",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_utf8test" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8test" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)fl_utf8test((char const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_nonspacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_nonspacing",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_nonspacing" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (unsigned int)fl_nonspacing(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8to_mb(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8to_mb",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_utf8to_mb" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8to_mb" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf8to_mb" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8to_mb" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = (unsigned int)fl_utf8to_mb((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf2mbcs",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_utf2mbcs" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (char *)fl_utf2mbcs((char const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf8from_mb(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  unsigned int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf8from_mb",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_utf8from_mb" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf8from_mb" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &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 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fl_utf8from_mb" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = (unsigned int)fl_utf8from_mb(arg1,arg2,(char const *)arg3,arg4);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< 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_utf_strncasecmp(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf_strncasecmp",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &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 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &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 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fl_utf_strncasecmp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)fl_utf_strncasecmp((char const *)arg1,(char const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_strcasecmp(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf_strcasecmp",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_utf_strcasecmp" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_utf_strcasecmp" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)fl_utf_strcasecmp((char const *)arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_tolower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_tolower",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_tolower" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (int)fl_tolower(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_toupper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_toupper",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fl_toupper" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (int)fl_toupper(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_tolower(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  arg3 = &temp3;
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf_tolower",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< unsigned char * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf_tolower" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)fl_utf_tolower((unsigned char const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_char((*arg3)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_utf_toupper(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_utf_toupper",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< unsigned char * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_utf_toupper" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fl_utf_toupper" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (int)fl_utf_toupper((unsigned char const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_chmod(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_chmod",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_chmod" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_chmod" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)fl_chmod((char const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_access(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_access",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_access" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_access" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)fl_access((char const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_getcwd(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_getcwd",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_getcwd" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_getcwd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)fl_getcwd(arg1,arg2);
  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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FILE *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_fopen",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_fopen" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_fopen" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (FILE *)fl_fopen((char const *)arg1,(char const *)arg2);
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_system",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_system" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)fl_system((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_execvp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char **arg2 = (char **) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_execvp",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_execvp" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    /* Check if it is a list */
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
        
#if PY_VERSION_HEX>=0x03000000
        if (PyUnicode_Check(o))
#else  
        if (PyString_Check(o))
#endif
        {
          //arg2[i] = PyString_AsString(PyList_GetItem(obj1,i));
          arg2[i] = SWIG_Python_str_AsChar(PyList_GetItem(obj1,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;
    }
  }
  result = (int)fl_execvp((char const *)arg1,(char *const *)arg2);
  resultobj = SWIG_From_int(static_cast< 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 *SWIGUNUSEDPARM(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;
  
  if(!PyArg_UnpackTuple(args,(char *)"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 = reinterpret_cast< 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 = static_cast< int >(val2);
  result = (int)fl_open((char const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_open(PyObject *SWIGUNUSEDPARM(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);
  Py_XDECREF(newargs);
  Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_fl_unlink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_unlink",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_unlink" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)fl_unlink((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rmdir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rmdir",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_rmdir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)fl_rmdir((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_getenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_getenv",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_getenv" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (char *)fl_getenv((char const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_mkdir(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_mkdir",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_mkdir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fl_mkdir" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)fl_mkdir((char const *)arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_rename(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_rename",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_rename" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fl_rename" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)fl_rename((char const *)arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_make_path_for_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_make_path_for_file",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_make_path_for_file" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  fl_make_path_for_file((char const *)arg1);
  resultobj = SWIG_Py_Void();
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fl_make_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if(!PyArg_UnpackTuple(args,(char *)"fl_make_path",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_make_path" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (char)fl_make_path((char const *)arg1);
  resultobj = SWIG_NewPointerObj((new char(static_cast< const char& >(result))), SWIGTYPE_p_char, SWIG_POINTER_OWN |  0 );
  {
    //printf("NewFreeArgTypemap");
  }
  return resultobj;
fail:
  {
    //printf("NewFreeArgTypemap");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_upCB(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"upCB",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "upCB" "', argument " "2"" of type '" "void *""'"); 
  }
  upCB(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_downCB(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"downCB",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "downCB" "', argument " "2"" of type '" "void *""'"); 
  }
  downCB(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_toggleCB(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"toggleCB",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Widget * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "toggleCB" "', argument " "2"" of type '" "void *""'"); 
  }
  toggleCB(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListSelect(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  ListSelect *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_ListSelect",5,7,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListSelect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ListSelect" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ListSelect" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ListSelect" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ListSelect" "', argument " "6"" of type '" "char *""'");
    }
    arg6 = reinterpret_cast< char * >(buf6);
  }
  if (obj6) {
    res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ListSelect" "', argument " "7"" of type '" "char *""'");
    }
    arg7 = reinterpret_cast< char * >(buf7);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Multi_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"ListSelect_getTopBrowser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< ListSelect * >(argp1);
  result = (Fl_Multi_Browser *)(arg1)->getTopBrowser();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Fl_Multi_Browser *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"ListSelect_getBottomBrowser",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< ListSelect * >(argp1);
  result = (Fl_Multi_Browser *)(arg1)->getBottomBrowser();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ListSelect *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"ListSelect_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< ListSelect * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListSelect_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListSelect_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListSelect_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ListSelect_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ListSelect *>(arg1);
    if (upcall) {
      (darg)->resizeSwigPublic(arg2,arg3,arg4,arg5);
    } else {
      (darg)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListSelect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_ListSelect",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< ListSelect * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_ListSelect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_ListSelect",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListSelect *arg1 = (ListSelect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ListSelect *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"ListSelect_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ListSelect *>(arg1);
    if (upcall) {
      (darg)->drawSwigPublic();
    } else {
      (darg)->draw();
    }
  } 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListSelect, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Table_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table *>(arg1);
    if (upcall) {
      result = (int)(darg)->handleSwigPublic(arg2);
    } else {
      result = (int)(darg)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_draw_cell(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_draw_cell",2,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Table::TableContext >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_draw_cell" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_draw_cell" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_draw_cell" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Table_draw_cell" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Table_draw_cell" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Table_draw_cell" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Table(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Table *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Table",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Table" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Table" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Table" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Table" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Table",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Table::clear();
    } else {
      (arg1)->clear();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_table_box__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Boxtype arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_table_box",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_table_box" "', argument " "2"" of type '" "Fl_Boxtype""'");
  } 
  arg2 = static_cast< Fl_Boxtype >(val2);
  (arg1)->table_box(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_table_box__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Boxtype result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_table_box",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (Fl_Boxtype)(arg1)->table_box();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_table_box(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_table_box__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_table_box__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_rows",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_rows" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Table::rows(arg2);
    } else {
      (arg1)->rows(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_rows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_rows",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->rows();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_rows(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_rows__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_rows__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_cols",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_cols" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Table::cols(arg2);
    } else {
      (arg1)->cols(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_cols__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_cols",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->cols();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_cols(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_cols__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_cols__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_visible_cells",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  (arg1)->visible_cells(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_is_interactive_resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_is_interactive_resize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->is_interactive_resize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_resize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->row_resize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_resize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->row_resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_row_resize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_row_resize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_resize",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->col_resize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_resize",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col_resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_col_resize__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_col_resize__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_resize_min",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->col_resize_min();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize_min__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_resize_min",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_resize_min" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col_resize_min(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_resize_min(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_col_resize_min__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_col_resize_min__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_resize_min",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->row_resize_min();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize_min__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_resize_min",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_resize_min" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->row_resize_min(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_resize_min(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_row_resize_min__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_row_resize_min__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_header",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->row_header();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_header",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_header" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->row_header(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_row_header__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_row_header__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_header",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->col_header();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_header",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_header" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col_header(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_col_header__SWIG_0(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_col_header__SWIG_1(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_header_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_header_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col_header_height(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_height__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_header_height",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->col_header_height();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_height(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_col_header_height__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_col_header_height__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_header_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_header_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->row_header_width(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_width__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_header_width",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->row_header_width();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_width(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_row_header_width__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_row_header_width__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_header_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->row_header_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_header_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (Fl_Color)(arg1)->row_header_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_header_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_row_header_color__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_row_header_color__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  Fl_Color arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_header_color",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &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 = static_cast< Fl_Color >(val2);
  (arg1)->col_header_color(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_color__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Color result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_header_color",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (Fl_Color)(arg1)->col_header_color();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_header_color(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_col_header_color__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_col_header_color__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_height",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_row_height" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->row_height(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_height__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_height",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_height" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->row_height(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_height(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_row_height__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Table_row_height__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_width",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_col_width" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->col_width(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_width__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_width",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->col_width(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_width(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_col_width__SWIG_1(self, args);
  }
  if (argc == 3) {
    return _wrap_Fl_Table_col_width__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_height_all",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_height_all" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->row_height_all(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_width_all(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_width_all",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_width_all" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col_width_all(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_position__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_position",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_row_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->row_position(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_position__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_position",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_col_position" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col_position(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_position__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_row_position",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->row_position();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_row_position(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_row_position__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_row_position__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_col_position",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->col_position();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_col_position(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_col_position__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_col_position__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_top_row",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_top_row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->top_row(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_top_row__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_top_row",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->top_row();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_top_row(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_top_row__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_top_row__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_is_selected",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_is_selected" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_is_selected" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->is_selected(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_get_selection(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_get_selection",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 *""'"); 
  }
  arg1 = reinterpret_cast< Fl_Table * >(argp1);
  (arg1)->get_selection(*arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } 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));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } 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));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } 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));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } 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));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_set_selection(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_set_selection",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_set_selection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_set_selection" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_set_selection" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_set_selection" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->set_selection(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_move_cursor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_move_cursor",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_move_cursor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_move_cursor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_move_cursor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)(arg1)->move_cursor(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_move_cursor__SWIG_1(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_move_cursor",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_move_cursor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_move_cursor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->move_cursor(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_move_cursor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    return _wrap_Fl_Table_move_cursor__SWIG_1(self, args);
  }
  if (argc == 4) {
    return _wrap_Fl_Table_move_cursor__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_resize",5,5,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_resize" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_resize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_resize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Table::resize(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->resize(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_draw",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Table::draw();
    } else {
      (arg1)->draw();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_init_sizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_init_sizes",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  (arg1)->init_sizes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_add(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_add",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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 = reinterpret_cast< Fl_Widget * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_insert(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_insert",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Table_insert" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_insert" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insert(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_insert_before(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_insert_before",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Table_insert_before" "', argument " "2"" of type '" "Fl_Widget &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &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 = reinterpret_cast< Fl_Widget * >(argp3);
  (arg1)->insert(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_begin",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  (arg1)->begin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_end",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  (arg1)->end();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_child(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  Fl_Widget *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_child",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_child" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Fl_Widget *)((Fl_Table const *)arg1)->child(arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_children",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)((Fl_Table const *)arg1)->children();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_find(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_find",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &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_ValueError, "invalid null reference " "in method '" "Fl_Table_find" "', argument " "2"" of type '" "Fl_Widget const &""'"); 
  }
  arg2 = reinterpret_cast< Fl_Widget * >(argp2);
  result = (int)((Fl_Table const *)arg1)->find((Fl_Widget const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_callback_row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_callback_row",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->callback_row();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_callback_col(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_callback_col",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (int)(arg1)->callback_col();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_callback_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Table::TableContext result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_callback_context",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  result = (Fl_Table::TableContext)(arg1)->callback_context();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_do_callback(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_do_callback",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Table::TableContext >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_do_callback" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_do_callback" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->do_callback(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Table(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table *arg1 = (Fl_Table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Table",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Table, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Fl_Table_Row_handle(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table_Row *darg = 0;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_handle",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_handle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table_Row *>(arg1);
    if (upcall) {
      result = (int)(darg)->handleSwigPublic(arg2);
    } else {
      result = (int)(darg)->handle(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fl_Table_Row(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Fl_Table_Row *result = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"new_Fl_Table_Row",5,6,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Fl_Table_Row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fl_Table_Row" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fl_Table_Row" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fl_Table_Row" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  if (obj5) {
    res6 = SWIG_AsCharPtrAndSize(obj5, &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 = reinterpret_cast< char * >(buf6);
  }
  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); 
  }
  
  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 *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"delete_Fl_Table_Row",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_rows__SWIG_0(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_rows",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_rows" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Table_Row::rows(arg2);
    } else {
      (arg1)->rows(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_rows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_rows",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  result = (int)(arg1)->rows();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_rows(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_Row_rows__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_Row_rows__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(self), PyObject *args) {
  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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_type",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Table_Row::TableRowSelectMode >(val2);
  (arg1)->type(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_type__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Fl_Table_Row::TableRowSelectMode result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_type",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  result = (Fl_Table_Row::TableRowSelectMode)((Fl_Table_Row const *)arg1)->type();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_type(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    return _wrap_Fl_Table_Row_type__SWIG_1(self, args);
  }
  if (argc == 2) {
    return _wrap_Fl_Table_Row_type__SWIG_0(self, args);
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"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 *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_row_selected",2,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_row_selected" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->row_selected(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_select_row(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_select_row",2,3,&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fl_Table_Row_select_row" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_Row_select_row" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  result = (int)(arg1)->select_row(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_select_all_rows(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_select_all_rows",1,2,&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< int >(val2);
  }
  (arg1)->select_all_rows(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fl_Table_Row_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_clear",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Fl_Table_Row::clear();
    } else {
      (arg1)->clear();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Fl_Table_Row(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Fl_Table_Row *arg1 = (Fl_Table_Row *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"disown_Fl_Table_Row",1,1,&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< 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_cell(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_Fl_Table_Row *darg = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"Fl_Table_Row_draw_cell",2,8,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &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 = reinterpret_cast< Fl_Table_Row * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &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 = static_cast< Fl_Table::TableContext >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fl_Table_Row_draw_cell" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fl_Table_Row_draw_cell" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Fl_Table_Row_draw_cell" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Fl_Table_Row_draw_cell" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Fl_Table_Row_draw_cell" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Fl_Table_Row_draw_cell" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< 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()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_Fl_Table_Row *>(arg1);
    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&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fl_Table_Row_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Fl_Table_Row, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_glLoadIdentity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"glLoadIdentity",0,0)) SWIG_fail;
  glLoadIdentity();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glViewport(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"glViewport",4,4,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glViewport" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "glViewport" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "glViewport" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "glViewport" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  glViewport(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glClear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"glClear",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glClear" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  glClear(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glColor3f(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"glColor3f",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glColor3f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "glColor3f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "glColor3f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  glColor3f(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"glBegin",1,1,&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glBegin" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  glBegin(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if(!PyArg_UnpackTuple(args,(char *)"glEnd",0,0)) SWIG_fail;
  glEnd();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_glVertex3f(PyObject *SWIGUNUSEDPARM(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 * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if(!PyArg_UnpackTuple(args,(char *)"glVertex3f",3,3,&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_float(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "glVertex3f" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "glVertex3f" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "glVertex3f" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  glVertex3f(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"fl_define_FL_ROUND_UP_BOX", _wrap_fl_define_FL_ROUND_UP_BOX, METH_VARARGS, (char *)"fl_define_FL_ROUND_UP_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_SHADOW_BOX", _wrap_fl_define_FL_SHADOW_BOX, METH_VARARGS, (char *)"fl_define_FL_SHADOW_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_ROUNDED_BOX", _wrap_fl_define_FL_ROUNDED_BOX, METH_VARARGS, (char *)"fl_define_FL_ROUNDED_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_RFLAT_BOX", _wrap_fl_define_FL_RFLAT_BOX, METH_VARARGS, (char *)"fl_define_FL_RFLAT_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_RSHADOW_BOX", _wrap_fl_define_FL_RSHADOW_BOX, METH_VARARGS, (char *)"fl_define_FL_RSHADOW_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_DIAMOND_BOX", _wrap_fl_define_FL_DIAMOND_BOX, METH_VARARGS, (char *)"fl_define_FL_DIAMOND_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_OVAL_BOX", _wrap_fl_define_FL_OVAL_BOX, METH_VARARGS, (char *)"fl_define_FL_OVAL_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_PLASTIC_UP_BOX", _wrap_fl_define_FL_PLASTIC_UP_BOX, METH_VARARGS, (char *)"fl_define_FL_PLASTIC_UP_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_GTK_UP_BOX", _wrap_fl_define_FL_GTK_UP_BOX, METH_VARARGS, (char *)"fl_define_FL_GTK_UP_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_GLEAM_UP_BOX", _wrap_fl_define_FL_GLEAM_UP_BOX, METH_VARARGS, (char *)"fl_define_FL_GLEAM_UP_BOX() -> Fl_Boxtype"},
	 { (char *)"fl_box", _wrap_fl_box, METH_VARARGS, (char *)"fl_box(Fl_Boxtype b) -> Fl_Boxtype"},
	 { (char *)"fl_down", _wrap_fl_down, METH_VARARGS, (char *)"fl_down(Fl_Boxtype b) -> Fl_Boxtype"},
	 { (char *)"fl_define_FL_SHADOW_LABEL", _wrap_fl_define_FL_SHADOW_LABEL, METH_VARARGS, (char *)"fl_define_FL_SHADOW_LABEL() -> Fl_Labeltype"},
	 { (char *)"fl_define_FL_ENGRAVED_LABEL", _wrap_fl_define_FL_ENGRAVED_LABEL, METH_VARARGS, (char *)"fl_define_FL_ENGRAVED_LABEL() -> Fl_Labeltype"},
	 { (char *)"fl_define_FL_EMBOSSED_LABEL", _wrap_fl_define_FL_EMBOSSED_LABEL, METH_VARARGS, (char *)"fl_define_FL_EMBOSSED_LABEL() -> Fl_Labeltype"},
	 { (char *)"fl_inactive", _wrap_fl_inactive, METH_VARARGS, (char *)"fl_inactive(Fl_Color c) -> Fl_Color"},
	 { (char *)"fl_contrast", _wrap_fl_contrast, METH_VARARGS, (char *)"fl_contrast(Fl_Color fg, Fl_Color bg) -> Fl_Color"},
	 { (char *)"fl_color_average", _wrap_fl_color_average, METH_VARARGS, (char *)"fl_color_average(Fl_Color c1, Fl_Color c2, float weight) -> Fl_Color"},
	 { (char *)"fl_lighter", _wrap_fl_lighter, METH_VARARGS, (char *)"fl_lighter(Fl_Color c) -> Fl_Color"},
	 { (char *)"fl_darker", _wrap_fl_darker, METH_VARARGS, (char *)"fl_darker(Fl_Color c) -> Fl_Color"},
	 { (char *)"fl_rgb_color", _wrap_fl_rgb_color, METH_VARARGS, (char *)"\n"
		"fl_rgb_color(uchar r, uchar g, uchar b) -> Fl_Color\n"
		"fl_rgb_color(uchar g) -> Fl_Color\n"
		""},
	 { (char *)"fl_gray_ramp", _wrap_fl_gray_ramp, METH_VARARGS, (char *)"fl_gray_ramp(int i) -> Fl_Color"},
	 { (char *)"fl_color_cube", _wrap_fl_color_cube, METH_VARARGS, (char *)"fl_color_cube(int r, int g, int b) -> Fl_Color"},
	 { (char *)"Fl_Image_w", _wrap_Fl_Image_w, METH_VARARGS, (char *)"Fl_Image_w(Fl_Image self) -> int"},
	 { (char *)"Fl_Image_h", _wrap_Fl_Image_h, METH_VARARGS, (char *)"Fl_Image_h(Fl_Image self) -> int"},
	 { (char *)"Fl_Image_d", _wrap_Fl_Image_d, METH_VARARGS, (char *)"Fl_Image_d(Fl_Image self) -> int"},
	 { (char *)"Fl_Image_ld", _wrap_Fl_Image_ld, METH_VARARGS, (char *)"Fl_Image_ld(Fl_Image self) -> int"},
	 { (char *)"Fl_Image_count", _wrap_Fl_Image_count, METH_VARARGS, (char *)"Fl_Image_count(Fl_Image self) -> int"},
	 { (char *)"Fl_Image_data", _wrap_Fl_Image_data, METH_VARARGS, (char *)"Fl_Image_data(Fl_Image self) -> char const *const *"},
	 { (char *)"Fl_Image_fail", _wrap_Fl_Image_fail, METH_VARARGS, (char *)"Fl_Image_fail(Fl_Image self) -> int"},
	 { (char *)"new_Fl_Image", _wrap_new_Fl_Image, METH_VARARGS, (char *)"new_Fl_Image(PyObject * self, int W, int H, int D) -> Fl_Image"},
	 { (char *)"delete_Fl_Image", _wrap_delete_Fl_Image, METH_VARARGS, (char *)"delete_Fl_Image(Fl_Image self)"},
	 { (char *)"Fl_Image_copy", _wrap_Fl_Image_copy, METH_VARARGS, (char *)"\n"
		"copy(int W, int H) -> Fl_Image\n"
		"Fl_Image_copy(Fl_Image self) -> Fl_Image\n"
		""},
	 { (char *)"Fl_Image_color_average", _wrap_Fl_Image_color_average, METH_VARARGS, (char *)"Fl_Image_color_average(Fl_Image self, Fl_Color c, float i)"},
	 { (char *)"Fl_Image_inactive", _wrap_Fl_Image_inactive, METH_VARARGS, (char *)"Fl_Image_inactive(Fl_Image self)"},
	 { (char *)"Fl_Image_desaturate", _wrap_Fl_Image_desaturate, METH_VARARGS, (char *)"Fl_Image_desaturate(Fl_Image self)"},
	 { (char *)"Fl_Image_label", _wrap_Fl_Image_label, METH_VARARGS, (char *)"\n"
		"label(Fl_Widget w)\n"
		"Fl_Image_label(Fl_Image self, Fl_Menu_Item m)\n"
		""},
	 { (char *)"Fl_Image_draw", _wrap_Fl_Image_draw, METH_VARARGS, (char *)"\n"
		"draw(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"
		""},
	 { (char *)"Fl_Image_uncache", _wrap_Fl_Image_uncache, METH_VARARGS, (char *)"Fl_Image_uncache(Fl_Image self)"},
	 { (char *)"Fl_Image_RGB_scaling", _wrap_Fl_Image_RGB_scaling, METH_VARARGS, (char *)"\n"
		"RGB_scaling(Fl_RGB_Scaling arg1)\n"
		"Fl_Image_RGB_scaling() -> Fl_RGB_Scaling\n"
		""},
	 { (char *)"disown_Fl_Image", _wrap_disown_Fl_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_Image_swigregister", Fl_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_RGB_Image", _wrap_new_Fl_RGB_Image, METH_VARARGS, (char *)"\n"
		"Fl_RGB_Image(uchar const * bits, int W, int H, int D=3, int LD=0)\n"
		"new_Fl_RGB_Image(PyObject * self, Fl_Pixmap pxm, Fl_Color bg=) -> Fl_RGB_Image\n"
		""},
	 { (char *)"delete_Fl_RGB_Image", _wrap_delete_Fl_RGB_Image, METH_VARARGS, (char *)"delete_Fl_RGB_Image(Fl_RGB_Image self)"},
	 { (char *)"Fl_RGB_Image_copy", _wrap_Fl_RGB_Image_copy, METH_VARARGS, (char *)"\n"
		"copy(int W, int H) -> Fl_Image\n"
		"Fl_RGB_Image_copy(Fl_RGB_Image self) -> Fl_Image\n"
		""},
	 { (char *)"Fl_RGB_Image_color_average", _wrap_Fl_RGB_Image_color_average, METH_VARARGS, (char *)"Fl_RGB_Image_color_average(Fl_RGB_Image self, Fl_Color c, float i)"},
	 { (char *)"Fl_RGB_Image_desaturate", _wrap_Fl_RGB_Image_desaturate, METH_VARARGS, (char *)"Fl_RGB_Image_desaturate(Fl_RGB_Image self)"},
	 { (char *)"Fl_RGB_Image_draw", _wrap_Fl_RGB_Image_draw, METH_VARARGS, (char *)"\n"
		"draw(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"
		""},
	 { (char *)"Fl_RGB_Image_label", _wrap_Fl_RGB_Image_label, METH_VARARGS, (char *)"\n"
		"label(Fl_Widget w)\n"
		"Fl_RGB_Image_label(Fl_RGB_Image self, Fl_Menu_Item m)\n"
		""},
	 { (char *)"Fl_RGB_Image_uncache", _wrap_Fl_RGB_Image_uncache, METH_VARARGS, (char *)"Fl_RGB_Image_uncache(Fl_RGB_Image self)"},
	 { (char *)"Fl_RGB_Image_max_size", _wrap_Fl_RGB_Image_max_size, METH_VARARGS, (char *)"\n"
		"max_size(size_t size)\n"
		"Fl_RGB_Image_max_size() -> size_t\n"
		""},
	 { (char *)"disown_Fl_RGB_Image", _wrap_disown_Fl_RGB_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_RGB_Image_swigregister", Fl_RGB_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Label_draw", _wrap_Fl_Label_draw, METH_VARARGS, (char *)"Fl_Label_draw(Fl_Label self, int arg2, int arg3, int arg4, int arg5, Fl_Align arg6)"},
	 { (char *)"Fl_Label_measure", _wrap_Fl_Label_measure, METH_VARARGS, (char *)"Fl_Label_measure(Fl_Label self, int & w, int & h)"},
	 { (char *)"new_Fl_Label", _wrap_new_Fl_Label, METH_VARARGS, (char *)"new_Fl_Label() -> Fl_Label"},
	 { (char *)"delete_Fl_Label", _wrap_delete_Fl_Label, METH_VARARGS, (char *)"delete_Fl_Label(Fl_Label self)"},
	 { (char *)"Fl_Label_swigregister", Fl_Label_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Widget", _wrap_new_Fl_Widget, METH_VARARGS, (char *)"new_Fl_Widget(PyObject * self, int x, int y, int w, int h, char const * label=0L) -> Fl_Widget"},
	 { (char *)"delete_Fl_Widget", _wrap_delete_Fl_Widget, METH_VARARGS, (char *)"delete_Fl_Widget(Fl_Widget self)"},
	 { (char *)"Fl_Widget_draw", _wrap_Fl_Widget_draw, METH_VARARGS, (char *)"Fl_Widget_draw(Fl_Widget self)"},
	 { (char *)"Fl_Widget_handle", _wrap_Fl_Widget_handle, METH_VARARGS, (char *)"Fl_Widget_handle(Fl_Widget self, int event) -> int"},
	 { (char *)"Fl_Widget_is_label_copied", _wrap_Fl_Widget_is_label_copied, METH_VARARGS, (char *)"Fl_Widget_is_label_copied(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_parent", _wrap_Fl_Widget_parent, METH_VARARGS, (char *)"\n"
		"parent() -> Fl_Group\n"
		"Fl_Widget_parent(Fl_Widget self, Fl_Group p)\n"
		""},
	 { (char *)"Fl_Widget_type", _wrap_Fl_Widget_type, METH_VARARGS, (char *)"\n"
		"type() -> uchar\n"
		"Fl_Widget_type(Fl_Widget self, uchar t)\n"
		""},
	 { (char *)"Fl_Widget_x", _wrap_Fl_Widget_x, METH_VARARGS, (char *)"Fl_Widget_x(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_y", _wrap_Fl_Widget_y, METH_VARARGS, (char *)"Fl_Widget_y(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_w", _wrap_Fl_Widget_w, METH_VARARGS, (char *)"Fl_Widget_w(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_h", _wrap_Fl_Widget_h, METH_VARARGS, (char *)"Fl_Widget_h(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_resize", _wrap_Fl_Widget_resize, METH_VARARGS, (char *)"Fl_Widget_resize(Fl_Widget self, int x, int y, int w, int h)"},
	 { (char *)"Fl_Widget_damage_resize", _wrap_Fl_Widget_damage_resize, METH_VARARGS, (char *)"Fl_Widget_damage_resize(Fl_Widget self, int arg2, int arg3, int arg4, int arg5) -> int"},
	 { (char *)"Fl_Widget_position", _wrap_Fl_Widget_position, METH_VARARGS, (char *)"Fl_Widget_position(Fl_Widget self, int X, int Y)"},
	 { (char *)"Fl_Widget_size", _wrap_Fl_Widget_size, METH_VARARGS, (char *)"Fl_Widget_size(Fl_Widget self, int W, int H)"},
	 { (char *)"Fl_Widget_align", _wrap_Fl_Widget_align, METH_VARARGS, (char *)"\n"
		"align() -> Fl_Align\n"
		"Fl_Widget_align(Fl_Widget self, Fl_Align alignment)\n"
		""},
	 { (char *)"Fl_Widget_box", _wrap_Fl_Widget_box, METH_VARARGS, (char *)"\n"
		"box() -> Fl_Boxtype\n"
		"Fl_Widget_box(Fl_Widget self, Fl_Boxtype new_box)\n"
		""},
	 { (char *)"Fl_Widget_selection_color", _wrap_Fl_Widget_selection_color, METH_VARARGS, (char *)"\n"
		"selection_color() -> Fl_Color\n"
		"Fl_Widget_selection_color(Fl_Widget self, Fl_Color a)\n"
		""},
	 { (char *)"Fl_Widget_color", _wrap_Fl_Widget_color, METH_VARARGS, (char *)"\n"
		"color() -> Fl_Color\n"
		"color(Fl_Color bg)\n"
		"Fl_Widget_color(Fl_Widget self, Fl_Color bg, Fl_Color sel)\n"
		""},
	 { (char *)"Fl_Widget_copy_label", _wrap_Fl_Widget_copy_label, METH_VARARGS, (char *)"Fl_Widget_copy_label(Fl_Widget self, char const * new_label)"},
	 { (char *)"Fl_Widget_label", _wrap_Fl_Widget_label, METH_VARARGS, (char *)"\n"
		"label() -> char const\n"
		"label(char const * text)\n"
		"Fl_Widget_label(Fl_Widget self, Fl_Labeltype a, char const * b)\n"
		""},
	 { (char *)"Fl_Widget_labeltype", _wrap_Fl_Widget_labeltype, METH_VARARGS, (char *)"\n"
		"labeltype() -> Fl_Labeltype\n"
		"Fl_Widget_labeltype(Fl_Widget self, Fl_Labeltype a)\n"
		""},
	 { (char *)"Fl_Widget_labelcolor", _wrap_Fl_Widget_labelcolor, METH_VARARGS, (char *)"\n"
		"labelcolor() -> Fl_Color\n"
		"Fl_Widget_labelcolor(Fl_Widget self, Fl_Color c)\n"
		""},
	 { (char *)"Fl_Widget_labelfont", _wrap_Fl_Widget_labelfont, METH_VARARGS, (char *)"\n"
		"labelfont() -> Fl_Font\n"
		"Fl_Widget_labelfont(Fl_Widget self, Fl_Font f)\n"
		""},
	 { (char *)"Fl_Widget_labelsize", _wrap_Fl_Widget_labelsize, METH_VARARGS, (char *)"\n"
		"labelsize() -> Fl_Fontsize\n"
		"Fl_Widget_labelsize(Fl_Widget self, Fl_Fontsize pix)\n"
		""},
	 { (char *)"Fl_Widget_image", _wrap_Fl_Widget_image, METH_VARARGS, (char *)"\n"
		"image() -> Fl_Image\n"
		"image() -> Fl_Image\n"
		"Fl_Widget_image(Fl_Widget self, Fl_Image img)\n"
		""},
	 { (char *)"Fl_Widget_deimage", _wrap_Fl_Widget_deimage, METH_VARARGS, (char *)"\n"
		"deimage() -> Fl_Image\n"
		"deimage() -> Fl_Image\n"
		"Fl_Widget_deimage(Fl_Widget self, Fl_Image img)\n"
		""},
	 { (char *)"Fl_Widget_tooltip", _wrap_Fl_Widget_tooltip, METH_VARARGS, (char *)"\n"
		"tooltip() -> char const\n"
		"Fl_Widget_tooltip(Fl_Widget self, char const * text)\n"
		""},
	 { (char *)"Fl_Widget_copy_tooltip", _wrap_Fl_Widget_copy_tooltip, METH_VARARGS, (char *)"Fl_Widget_copy_tooltip(Fl_Widget self, char const * text)"},
	 { (char *)"Fl_Widget_argument", _wrap_Fl_Widget_argument, METH_VARARGS, (char *)"\n"
		"argument() -> long\n"
		"Fl_Widget_argument(Fl_Widget self, long v)\n"
		""},
	 { (char *)"Fl_Widget_when", _wrap_Fl_Widget_when, METH_VARARGS, (char *)"\n"
		"when() -> Fl_When\n"
		"Fl_Widget_when(Fl_Widget self, uchar i)\n"
		""},
	 { (char *)"Fl_Widget_visible", _wrap_Fl_Widget_visible, METH_VARARGS, (char *)"Fl_Widget_visible(Fl_Widget self) -> unsigned int"},
	 { (char *)"Fl_Widget_visible_r", _wrap_Fl_Widget_visible_r, METH_VARARGS, (char *)"Fl_Widget_visible_r(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_show", _wrap_Fl_Widget_show, METH_VARARGS, (char *)"Fl_Widget_show(Fl_Widget self)"},
	 { (char *)"Fl_Widget_hide", _wrap_Fl_Widget_hide, METH_VARARGS, (char *)"Fl_Widget_hide(Fl_Widget self)"},
	 { (char *)"Fl_Widget_set_visible", _wrap_Fl_Widget_set_visible, METH_VARARGS, (char *)"Fl_Widget_set_visible(Fl_Widget self)"},
	 { (char *)"Fl_Widget_clear_visible", _wrap_Fl_Widget_clear_visible, METH_VARARGS, (char *)"Fl_Widget_clear_visible(Fl_Widget self)"},
	 { (char *)"Fl_Widget_active", _wrap_Fl_Widget_active, METH_VARARGS, (char *)"Fl_Widget_active(Fl_Widget self) -> unsigned int"},
	 { (char *)"Fl_Widget_active_r", _wrap_Fl_Widget_active_r, METH_VARARGS, (char *)"Fl_Widget_active_r(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_activate", _wrap_Fl_Widget_activate, METH_VARARGS, (char *)"Fl_Widget_activate(Fl_Widget self)"},
	 { (char *)"Fl_Widget_deactivate", _wrap_Fl_Widget_deactivate, METH_VARARGS, (char *)"Fl_Widget_deactivate(Fl_Widget self)"},
	 { (char *)"Fl_Widget_output", _wrap_Fl_Widget_output, METH_VARARGS, (char *)"Fl_Widget_output(Fl_Widget self) -> unsigned int"},
	 { (char *)"Fl_Widget_set_output", _wrap_Fl_Widget_set_output, METH_VARARGS, (char *)"Fl_Widget_set_output(Fl_Widget self)"},
	 { (char *)"Fl_Widget_clear_output", _wrap_Fl_Widget_clear_output, METH_VARARGS, (char *)"Fl_Widget_clear_output(Fl_Widget self)"},
	 { (char *)"Fl_Widget_takesevents", _wrap_Fl_Widget_takesevents, METH_VARARGS, (char *)"Fl_Widget_takesevents(Fl_Widget self) -> unsigned int"},
	 { (char *)"Fl_Widget_changed", _wrap_Fl_Widget_changed, METH_VARARGS, (char *)"Fl_Widget_changed(Fl_Widget self) -> unsigned int"},
	 { (char *)"Fl_Widget_set_changed", _wrap_Fl_Widget_set_changed, METH_VARARGS, (char *)"Fl_Widget_set_changed(Fl_Widget self)"},
	 { (char *)"Fl_Widget_clear_changed", _wrap_Fl_Widget_clear_changed, METH_VARARGS, (char *)"Fl_Widget_clear_changed(Fl_Widget self)"},
	 { (char *)"Fl_Widget_clear_active", _wrap_Fl_Widget_clear_active, METH_VARARGS, (char *)"Fl_Widget_clear_active(Fl_Widget self)"},
	 { (char *)"Fl_Widget_set_active", _wrap_Fl_Widget_set_active, METH_VARARGS, (char *)"Fl_Widget_set_active(Fl_Widget self)"},
	 { (char *)"Fl_Widget_take_focus", _wrap_Fl_Widget_take_focus, METH_VARARGS, (char *)"Fl_Widget_take_focus(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_set_visible_focus", _wrap_Fl_Widget_set_visible_focus, METH_VARARGS, (char *)"Fl_Widget_set_visible_focus(Fl_Widget self)"},
	 { (char *)"Fl_Widget_clear_visible_focus", _wrap_Fl_Widget_clear_visible_focus, METH_VARARGS, (char *)"Fl_Widget_clear_visible_focus(Fl_Widget self)"},
	 { (char *)"Fl_Widget_visible_focus", _wrap_Fl_Widget_visible_focus, METH_VARARGS, (char *)"\n"
		"visible_focus(int v)\n"
		"Fl_Widget_visible_focus(Fl_Widget self) -> unsigned int\n"
		""},
	 { (char *)"Fl_Widget_default_callback", _wrap_Fl_Widget_default_callback, METH_VARARGS, (char *)"Fl_Widget_default_callback(Fl_Widget cb, void * d)"},
	 { (char *)"Fl_Widget_do_callback", _wrap_Fl_Widget_do_callback, METH_VARARGS, (char *)"\n"
		"do_callback()\n"
		"do_callback(Fl_Widget o, long arg)\n"
		"Fl_Widget_do_callback(Fl_Widget self, Fl_Widget o, void * arg=None)\n"
		""},
	 { (char *)"Fl_Widget_label_shortcut", _wrap_Fl_Widget_label_shortcut, METH_VARARGS, (char *)"Fl_Widget_label_shortcut(char const * t) -> unsigned int"},
	 { (char *)"Fl_Widget_test_shortcut", _wrap_Fl_Widget_test_shortcut, METH_VARARGS, (char *)"\n"
		"test_shortcut() -> int\n"
		"Fl_Widget_test_shortcut(char const * arg1, bool const require_alt=False) -> int\n"
		""},
	 { (char *)"Fl_Widget__set_fullscreen", _wrap_Fl_Widget__set_fullscreen, METH_VARARGS, (char *)"Fl_Widget__set_fullscreen(Fl_Widget self)"},
	 { (char *)"Fl_Widget__clear_fullscreen", _wrap_Fl_Widget__clear_fullscreen, METH_VARARGS, (char *)"Fl_Widget__clear_fullscreen(Fl_Widget self)"},
	 { (char *)"Fl_Widget_contains", _wrap_Fl_Widget_contains, METH_VARARGS, (char *)"Fl_Widget_contains(Fl_Widget self, Fl_Widget w) -> int"},
	 { (char *)"Fl_Widget_inside", _wrap_Fl_Widget_inside, METH_VARARGS, (char *)"Fl_Widget_inside(Fl_Widget self, Fl_Widget wgt) -> int"},
	 { (char *)"Fl_Widget_redraw", _wrap_Fl_Widget_redraw, METH_VARARGS, (char *)"Fl_Widget_redraw(Fl_Widget self)"},
	 { (char *)"Fl_Widget_redraw_label", _wrap_Fl_Widget_redraw_label, METH_VARARGS, (char *)"Fl_Widget_redraw_label(Fl_Widget self)"},
	 { (char *)"Fl_Widget_clear_damage", _wrap_Fl_Widget_clear_damage, METH_VARARGS, (char *)"Fl_Widget_clear_damage(Fl_Widget self, uchar c=0)"},
	 { (char *)"Fl_Widget_damage", _wrap_Fl_Widget_damage, METH_VARARGS, (char *)"\n"
		"damage() -> uchar\n"
		"damage(uchar c)\n"
		"Fl_Widget_damage(Fl_Widget self, uchar c, int x, int y, int w, int h)\n"
		""},
	 { (char *)"Fl_Widget_measure_label", _wrap_Fl_Widget_measure_label, METH_VARARGS, (char *)"Fl_Widget_measure_label(Fl_Widget self, int & ww, int & hh)"},
	 { (char *)"Fl_Widget_window", _wrap_Fl_Widget_window, METH_VARARGS, (char *)"Fl_Widget_window(Fl_Widget self) -> Fl_Window"},
	 { (char *)"Fl_Widget_top_window", _wrap_Fl_Widget_top_window, METH_VARARGS, (char *)"Fl_Widget_top_window(Fl_Widget self) -> Fl_Window"},
	 { (char *)"Fl_Widget_top_window_offset", _wrap_Fl_Widget_top_window_offset, METH_VARARGS, (char *)"Fl_Widget_top_window_offset(Fl_Widget self, int & xoff, int & yoff) -> Fl_Window"},
	 { (char *)"Fl_Widget_as_group", _wrap_Fl_Widget_as_group, METH_VARARGS, (char *)"Fl_Widget_as_group(Fl_Widget self) -> Fl_Group"},
	 { (char *)"Fl_Widget_as_window", _wrap_Fl_Widget_as_window, METH_VARARGS, (char *)"Fl_Widget_as_window(Fl_Widget self) -> Fl_Window"},
	 { (char *)"Fl_Widget_as_gl_window", _wrap_Fl_Widget_as_gl_window, METH_VARARGS, (char *)"Fl_Widget_as_gl_window(Fl_Widget self) -> Fl_Gl_Window"},
	 { (char *)"Fl_Widget_use_accents_menu", _wrap_Fl_Widget_use_accents_menu, METH_VARARGS, (char *)"Fl_Widget_use_accents_menu(Fl_Widget self) -> int"},
	 { (char *)"Fl_Widget_color2", _wrap_Fl_Widget_color2, METH_VARARGS, (char *)"\n"
		"color2() -> Fl_Color\n"
		"Fl_Widget_color2(Fl_Widget self, unsigned int a)\n"
		""},
	 { (char *)"Fl_Widget_draw_label", _wrap_Fl_Widget_draw_label, METH_VARARGS, (char *)"\n"
		"draw_label(int arg2, int arg3, int arg4, int arg5, Fl_Align arg6)\n"
		"Fl_Widget_draw_label(Fl_Widget self)\n"
		""},
	 { (char *)"Fl_Widget_draw_backdrop", _wrap_Fl_Widget_draw_backdrop, METH_VARARGS, (char *)"Fl_Widget_draw_backdrop(Fl_Widget self)"},
	 { (char *)"Fl_Widget_callback", _wrap_Fl_Widget_callback, METH_VARARGS, (char *)"\n"
		"callback() -> Fl_Callback_p\n"
		"callback(Fl_Callback * cb, void * p)\n"
		"callback(Fl_Callback * cb)\n"
		"callback(Fl_Callback0 * cb)\n"
		"callback(Fl_Callback1 * cb, long p=0)\n"
		"Fl_Widget_callback(Fl_Widget self, PyObject * PyFunc, PyObject * PyWidget, PyObject * PyData=None)\n"
		""},
	 { (char *)"Fl_Widget_user_data", _wrap_Fl_Widget_user_data, METH_VARARGS, (char *)"\n"
		"user_data()\n"
		"user_data(void * v)\n"
		"user_data(PyObject * PyData)\n"
		"Fl_Widget_user_data(Fl_Widget self) -> PyObject *\n"
		""},
	 { (char *)"disown_Fl_Widget", _wrap_disown_Fl_Widget, METH_VARARGS, NULL},
	 { (char *)"Fl_Widget_swigregister", Fl_Widget_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Group_draw", _wrap_Fl_Group_draw, METH_VARARGS, (char *)"Fl_Group_draw(Fl_Group self)"},
	 { (char *)"Fl_Group_handle", _wrap_Fl_Group_handle, METH_VARARGS, (char *)"Fl_Group_handle(Fl_Group self, int arg0) -> int"},
	 { (char *)"Fl_Group_begin", _wrap_Fl_Group_begin, METH_VARARGS, (char *)"Fl_Group_begin(Fl_Group self)"},
	 { (char *)"Fl_Group_end", _wrap_Fl_Group_end, METH_VARARGS, (char *)"Fl_Group_end(Fl_Group self)"},
	 { (char *)"Fl_Group_current", _wrap_Fl_Group_current, METH_VARARGS, (char *)"\n"
		"current() -> Fl_Group\n"
		"Fl_Group_current(Fl_Group g)\n"
		""},
	 { (char *)"Fl_Group_children", _wrap_Fl_Group_children, METH_VARARGS, (char *)"Fl_Group_children(Fl_Group self) -> int"},
	 { (char *)"Fl_Group_child", _wrap_Fl_Group_child, METH_VARARGS, (char *)"Fl_Group_child(Fl_Group self, int n) -> Fl_Widget"},
	 { (char *)"Fl_Group_find", _wrap_Fl_Group_find, METH_VARARGS, (char *)"Fl_Group_find(Fl_Group self, Fl_Widget o) -> int"},
	 { (char *)"Fl_Group_resize", _wrap_Fl_Group_resize, METH_VARARGS, (char *)"Fl_Group_resize(Fl_Group self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"new_Fl_Group", _wrap_new_Fl_Group, METH_VARARGS, (char *)"new_Fl_Group(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Group"},
	 { (char *)"delete_Fl_Group", _wrap_delete_Fl_Group, METH_VARARGS, (char *)"delete_Fl_Group(Fl_Group self)"},
	 { (char *)"Fl_Group_add", _wrap_Fl_Group_add, METH_VARARGS, (char *)"Fl_Group_add(Fl_Group self, Fl_Widget o)"},
	 { (char *)"Fl_Group_insert", _wrap_Fl_Group_insert, METH_VARARGS, (char *)"Fl_Group_insert(Fl_Group self, Fl_Widget arg2, int i)"},
	 { (char *)"Fl_Group_insert_before", _wrap_Fl_Group_insert_before, METH_VARARGS, (char *)"Fl_Group_insert_before(Fl_Group self, Fl_Widget o, Fl_Widget before)"},
	 { (char *)"Fl_Group_remove", _wrap_Fl_Group_remove, METH_VARARGS, (char *)"\n"
		"remove(int index)\n"
		"Fl_Group_remove(Fl_Group self, Fl_Widget o)\n"
		""},
	 { (char *)"Fl_Group_clear", _wrap_Fl_Group_clear, METH_VARARGS, (char *)"Fl_Group_clear(Fl_Group self)"},
	 { (char *)"Fl_Group_resizable", _wrap_Fl_Group_resizable, METH_VARARGS, (char *)"\n"
		"resizable(Fl_Widget o)\n"
		"Fl_Group_resizable(Fl_Group self) -> Fl_Widget\n"
		""},
	 { (char *)"Fl_Group_add_resizable", _wrap_Fl_Group_add_resizable, METH_VARARGS, (char *)"Fl_Group_add_resizable(Fl_Group self, Fl_Widget o)"},
	 { (char *)"Fl_Group_init_sizes", _wrap_Fl_Group_init_sizes, METH_VARARGS, (char *)"Fl_Group_init_sizes(Fl_Group self)"},
	 { (char *)"Fl_Group_clip_children", _wrap_Fl_Group_clip_children, METH_VARARGS, (char *)"\n"
		"clip_children(int c)\n"
		"Fl_Group_clip_children(Fl_Group self) -> unsigned int\n"
		""},
	 { (char *)"Fl_Group_as_group", _wrap_Fl_Group_as_group, METH_VARARGS, (char *)"Fl_Group_as_group(Fl_Group self) -> Fl_Group"},
	 { (char *)"Fl_Group_focus", _wrap_Fl_Group_focus, METH_VARARGS, (char *)"Fl_Group_focus(Fl_Group self, Fl_Widget W)"},
	 { (char *)"Fl_Group__ddfdesign_kludge", _wrap_Fl_Group__ddfdesign_kludge, METH_VARARGS, (char *)"Fl_Group__ddfdesign_kludge(Fl_Group self) -> Fl_Widget *&"},
	 { (char *)"Fl_Group_forms_end", _wrap_Fl_Group_forms_end, METH_VARARGS, (char *)"Fl_Group_forms_end(Fl_Group self)"},
	 { (char *)"disown_Fl_Group", _wrap_disown_Fl_Group, METH_VARARGS, NULL},
	 { (char *)"Fl_Group_swigregister", Fl_Group_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_End", _wrap_new_Fl_End, METH_VARARGS, (char *)"new_Fl_End() -> Fl_End"},
	 { (char *)"delete_Fl_End", _wrap_delete_Fl_End, METH_VARARGS, (char *)"delete_Fl_End(Fl_End self)"},
	 { (char *)"Fl_End_swigregister", Fl_End_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Browser__item_first", _wrap_Fl_Browser__item_first, METH_VARARGS, (char *)"Fl_Browser__item_first(Fl_Browser_ self) -> void *"},
	 { (char *)"Fl_Browser__item_next", _wrap_Fl_Browser__item_next, METH_VARARGS, (char *)"Fl_Browser__item_next(Fl_Browser_ self, void * item) -> void *"},
	 { (char *)"Fl_Browser__item_prev", _wrap_Fl_Browser__item_prev, METH_VARARGS, (char *)"Fl_Browser__item_prev(Fl_Browser_ self, void * item) -> void *"},
	 { (char *)"Fl_Browser__item_last", _wrap_Fl_Browser__item_last, METH_VARARGS, (char *)"Fl_Browser__item_last(Fl_Browser_ self) -> void *"},
	 { (char *)"Fl_Browser__item_height", _wrap_Fl_Browser__item_height, METH_VARARGS, (char *)"Fl_Browser__item_height(Fl_Browser_ self, void * item) -> int"},
	 { (char *)"Fl_Browser__item_width", _wrap_Fl_Browser__item_width, METH_VARARGS, (char *)"Fl_Browser__item_width(Fl_Browser_ self, void * item) -> int"},
	 { (char *)"Fl_Browser__item_quick_height", _wrap_Fl_Browser__item_quick_height, METH_VARARGS, (char *)"Fl_Browser__item_quick_height(Fl_Browser_ self, void * item) -> int"},
	 { (char *)"Fl_Browser__item_draw", _wrap_Fl_Browser__item_draw, METH_VARARGS, (char *)"Fl_Browser__item_draw(Fl_Browser_ self, void * item, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Browser__item_text", _wrap_Fl_Browser__item_text, METH_VARARGS, (char *)"Fl_Browser__item_text(Fl_Browser_ self, void * item) -> char const *"},
	 { (char *)"Fl_Browser__item_swap", _wrap_Fl_Browser__item_swap, METH_VARARGS, (char *)"Fl_Browser__item_swap(Fl_Browser_ self, void * a, void * b)"},
	 { (char *)"Fl_Browser__item_at", _wrap_Fl_Browser__item_at, METH_VARARGS, (char *)"Fl_Browser__item_at(Fl_Browser_ self, int index) -> void *"},
	 { (char *)"Fl_Browser__full_width", _wrap_Fl_Browser__full_width, METH_VARARGS, (char *)"Fl_Browser__full_width(Fl_Browser_ self) -> int"},
	 { (char *)"Fl_Browser__full_height", _wrap_Fl_Browser__full_height, METH_VARARGS, (char *)"Fl_Browser__full_height(Fl_Browser_ self) -> int"},
	 { (char *)"Fl_Browser__incr_height", _wrap_Fl_Browser__incr_height, METH_VARARGS, (char *)"Fl_Browser__incr_height(Fl_Browser_ self) -> int"},
	 { (char *)"Fl_Browser__item_select", _wrap_Fl_Browser__item_select, METH_VARARGS, (char *)"Fl_Browser__item_select(Fl_Browser_ self, void * item, int val=1)"},
	 { (char *)"Fl_Browser__item_selected", _wrap_Fl_Browser__item_selected, METH_VARARGS, (char *)"Fl_Browser__item_selected(Fl_Browser_ self, void * item) -> int"},
	 { (char *)"Fl_Browser__draw", _wrap_Fl_Browser__draw, METH_VARARGS, (char *)"Fl_Browser__draw(Fl_Browser_ self)"},
	 { (char *)"new_Fl_Browser_", _wrap_new_Fl_Browser_, METH_VARARGS, (char *)"new_Fl_Browser_(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Browser_"},
	 { (char *)"Fl_Browser__handle", _wrap_Fl_Browser__handle, METH_VARARGS, (char *)"Fl_Browser__handle(Fl_Browser_ self, int event) -> int"},
	 { (char *)"Fl_Browser__resize", _wrap_Fl_Browser__resize, METH_VARARGS, (char *)"Fl_Browser__resize(Fl_Browser_ self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Browser__select", _wrap_Fl_Browser__select, METH_VARARGS, (char *)"Fl_Browser__select(Fl_Browser_ self, void * item, int val=1, int docallbacks=0) -> int"},
	 { (char *)"Fl_Browser__select_only", _wrap_Fl_Browser__select_only, METH_VARARGS, (char *)"Fl_Browser__select_only(Fl_Browser_ self, void * item, int docallbacks=0) -> int"},
	 { (char *)"Fl_Browser__deselect", _wrap_Fl_Browser__deselect, METH_VARARGS, (char *)"Fl_Browser__deselect(Fl_Browser_ self, int docallbacks=0) -> int"},
	 { (char *)"Fl_Browser__position", _wrap_Fl_Browser__position, METH_VARARGS, (char *)"\n"
		"position() -> int\n"
		"Fl_Browser__position(Fl_Browser_ self, int pos)\n"
		""},
	 { (char *)"Fl_Browser__hposition", _wrap_Fl_Browser__hposition, METH_VARARGS, (char *)"\n"
		"hposition() -> int\n"
		"Fl_Browser__hposition(Fl_Browser_ self, int arg2)\n"
		""},
	 { (char *)"Fl_Browser__display", _wrap_Fl_Browser__display, METH_VARARGS, (char *)"Fl_Browser__display(Fl_Browser_ self, void * item)"},
	 { (char *)"Fl_Browser__has_scrollbar", _wrap_Fl_Browser__has_scrollbar, METH_VARARGS, (char *)"\n"
		"has_scrollbar() -> uchar\n"
		"Fl_Browser__has_scrollbar(Fl_Browser_ self, uchar mode)\n"
		""},
	 { (char *)"Fl_Browser__textfont", _wrap_Fl_Browser__textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Browser__textfont(Fl_Browser_ self, Fl_Font font)\n"
		""},
	 { (char *)"Fl_Browser__textsize", _wrap_Fl_Browser__textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Browser__textsize(Fl_Browser_ self, Fl_Fontsize newSize)\n"
		""},
	 { (char *)"Fl_Browser__textcolor", _wrap_Fl_Browser__textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Browser__textcolor(Fl_Browser_ self, Fl_Color col)\n"
		""},
	 { (char *)"Fl_Browser__scrollbar_size", _wrap_Fl_Browser__scrollbar_size, METH_VARARGS, (char *)"\n"
		"scrollbar_size() -> int\n"
		"Fl_Browser__scrollbar_size(Fl_Browser_ self, int newSize)\n"
		""},
	 { (char *)"Fl_Browser__scrollbar_width", _wrap_Fl_Browser__scrollbar_width, METH_VARARGS, (char *)"\n"
		"scrollbar_width() -> int\n"
		"Fl_Browser__scrollbar_width(Fl_Browser_ self, int width)\n"
		""},
	 { (char *)"Fl_Browser__scrollbar_right", _wrap_Fl_Browser__scrollbar_right, METH_VARARGS, (char *)"Fl_Browser__scrollbar_right(Fl_Browser_ self)"},
	 { (char *)"Fl_Browser__scrollbar_left", _wrap_Fl_Browser__scrollbar_left, METH_VARARGS, (char *)"Fl_Browser__scrollbar_left(Fl_Browser_ self)"},
	 { (char *)"Fl_Browser__sort", _wrap_Fl_Browser__sort, METH_VARARGS, (char *)"Fl_Browser__sort(Fl_Browser_ self, int flags=0)"},
	 { (char *)"Fl_Browser__getScrollbar", _wrap_Fl_Browser__getScrollbar, METH_VARARGS, (char *)"Fl_Browser__getScrollbar(Fl_Browser_ self) -> Fl_Scrollbar"},
	 { (char *)"Fl_Browser__getHScrollbar", _wrap_Fl_Browser__getHScrollbar, METH_VARARGS, (char *)"Fl_Browser__getHScrollbar(Fl_Browser_ self) -> Fl_Scrollbar"},
	 { (char *)"delete_Fl_Browser_", _wrap_delete_Fl_Browser_, METH_VARARGS, (char *)"delete_Fl_Browser_(Fl_Browser_ self)"},
	 { (char *)"disown_Fl_Browser_", _wrap_disown_Fl_Browser_, METH_VARARGS, NULL},
	 { (char *)"Fl_Browser__swigregister", Fl_Browser__swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Browser_item_first", _wrap_Fl_Browser_item_first, METH_VARARGS, (char *)"Fl_Browser_item_first(Fl_Browser self) -> void *"},
	 { (char *)"Fl_Browser_item_next", _wrap_Fl_Browser_item_next, METH_VARARGS, (char *)"Fl_Browser_item_next(Fl_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Browser_item_prev", _wrap_Fl_Browser_item_prev, METH_VARARGS, (char *)"Fl_Browser_item_prev(Fl_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Browser_item_last", _wrap_Fl_Browser_item_last, METH_VARARGS, (char *)"Fl_Browser_item_last(Fl_Browser self) -> void *"},
	 { (char *)"Fl_Browser_item_selected", _wrap_Fl_Browser_item_selected, METH_VARARGS, (char *)"Fl_Browser_item_selected(Fl_Browser self, void * item) -> int"},
	 { (char *)"Fl_Browser_item_select", _wrap_Fl_Browser_item_select, METH_VARARGS, (char *)"Fl_Browser_item_select(Fl_Browser self, void * item, int val)"},
	 { (char *)"Fl_Browser_item_height", _wrap_Fl_Browser_item_height, METH_VARARGS, (char *)"Fl_Browser_item_height(Fl_Browser self, void * item) -> int"},
	 { (char *)"Fl_Browser_item_width", _wrap_Fl_Browser_item_width, METH_VARARGS, (char *)"Fl_Browser_item_width(Fl_Browser self, void * item) -> int"},
	 { (char *)"Fl_Browser_item_draw", _wrap_Fl_Browser_item_draw, METH_VARARGS, (char *)"Fl_Browser_item_draw(Fl_Browser self, void * item, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Browser_full_height", _wrap_Fl_Browser_full_height, METH_VARARGS, (char *)"Fl_Browser_full_height(Fl_Browser self) -> int"},
	 { (char *)"Fl_Browser_incr_height", _wrap_Fl_Browser_incr_height, METH_VARARGS, (char *)"Fl_Browser_incr_height(Fl_Browser self) -> int"},
	 { (char *)"Fl_Browser_item_text", _wrap_Fl_Browser_item_text, METH_VARARGS, (char *)"Fl_Browser_item_text(Fl_Browser self, void * item) -> char const *"},
	 { (char *)"Fl_Browser_item_swap", _wrap_Fl_Browser_item_swap, METH_VARARGS, (char *)"Fl_Browser_item_swap(Fl_Browser self, void * a, void * b)"},
	 { (char *)"Fl_Browser_item_at", _wrap_Fl_Browser_item_at, METH_VARARGS, (char *)"Fl_Browser_item_at(Fl_Browser self, int line) -> void *"},
	 { (char *)"Fl_Browser_remove", _wrap_Fl_Browser_remove, METH_VARARGS, (char *)"Fl_Browser_remove(Fl_Browser self, int line)"},
	 { (char *)"Fl_Browser_move", _wrap_Fl_Browser_move, METH_VARARGS, (char *)"Fl_Browser_move(Fl_Browser self, int to, int _from)"},
	 { (char *)"Fl_Browser_load", _wrap_Fl_Browser_load, METH_VARARGS, (char *)"Fl_Browser_load(Fl_Browser self, char const * filename) -> int"},
	 { (char *)"Fl_Browser_swap", _wrap_Fl_Browser_swap, METH_VARARGS, (char *)"Fl_Browser_swap(Fl_Browser self, int a, int b)"},
	 { (char *)"Fl_Browser_clear", _wrap_Fl_Browser_clear, METH_VARARGS, (char *)"Fl_Browser_clear(Fl_Browser self)"},
	 { (char *)"Fl_Browser_size", _wrap_Fl_Browser_size, METH_VARARGS, (char *)"\n"
		"size() -> int\n"
		"Fl_Browser_size(Fl_Browser self, int W, int H)\n"
		""},
	 { (char *)"Fl_Browser_textsize", _wrap_Fl_Browser_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Browser_textsize(Fl_Browser self, Fl_Fontsize newSize)\n"
		""},
	 { (char *)"Fl_Browser_lineposition", _wrap_Fl_Browser_lineposition, METH_VARARGS, (char *)"Fl_Browser_lineposition(Fl_Browser self, int line, Fl_Browser::Fl_Line_Position pos)"},
	 { (char *)"Fl_Browser_topline", _wrap_Fl_Browser_topline, METH_VARARGS, (char *)"\n"
		"topline() -> int\n"
		"Fl_Browser_topline(Fl_Browser self, int line)\n"
		""},
	 { (char *)"Fl_Browser_bottomline", _wrap_Fl_Browser_bottomline, METH_VARARGS, (char *)"Fl_Browser_bottomline(Fl_Browser self, int line)"},
	 { (char *)"Fl_Browser_middleline", _wrap_Fl_Browser_middleline, METH_VARARGS, (char *)"Fl_Browser_middleline(Fl_Browser self, int line)"},
	 { (char *)"Fl_Browser_select", _wrap_Fl_Browser_select, METH_VARARGS, (char *)"Fl_Browser_select(Fl_Browser self, int line, int val=1) -> int"},
	 { (char *)"Fl_Browser_selected", _wrap_Fl_Browser_selected, METH_VARARGS, (char *)"Fl_Browser_selected(Fl_Browser self, int line) -> int"},
	 { (char *)"Fl_Browser_show", _wrap_Fl_Browser_show, METH_VARARGS, (char *)"\n"
		"show(int line)\n"
		"Fl_Browser_show(Fl_Browser self)\n"
		""},
	 { (char *)"Fl_Browser_hide", _wrap_Fl_Browser_hide, METH_VARARGS, (char *)"\n"
		"hide(int line)\n"
		"Fl_Browser_hide(Fl_Browser self)\n"
		""},
	 { (char *)"Fl_Browser_visible", _wrap_Fl_Browser_visible, METH_VARARGS, (char *)"Fl_Browser_visible(Fl_Browser self, int line) -> int"},
	 { (char *)"Fl_Browser_value", _wrap_Fl_Browser_value, METH_VARARGS, (char *)"\n"
		"value() -> int\n"
		"Fl_Browser_value(Fl_Browser self, int line)\n"
		""},
	 { (char *)"Fl_Browser_text", _wrap_Fl_Browser_text, METH_VARARGS, (char *)"\n"
		"text(int line) -> char const\n"
		"Fl_Browser_text(Fl_Browser self, int line, char const * newtext)\n"
		""},
	 { (char *)"new_Fl_Browser", _wrap_new_Fl_Browser, METH_VARARGS, (char *)"new_Fl_Browser(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Browser"},
	 { (char *)"delete_Fl_Browser", _wrap_delete_Fl_Browser, METH_VARARGS, (char *)"delete_Fl_Browser(Fl_Browser self)"},
	 { (char *)"Fl_Browser_format_char", _wrap_Fl_Browser_format_char, METH_VARARGS, (char *)"\n"
		"format_char() -> char\n"
		"Fl_Browser_format_char(Fl_Browser self, char c)\n"
		""},
	 { (char *)"Fl_Browser_column_char", _wrap_Fl_Browser_column_char, METH_VARARGS, (char *)"\n"
		"column_char() -> char\n"
		"Fl_Browser_column_char(Fl_Browser self, char c)\n"
		""},
	 { (char *)"Fl_Browser_displayed", _wrap_Fl_Browser_displayed, METH_VARARGS, (char *)"Fl_Browser_displayed(Fl_Browser self, int line) -> int"},
	 { (char *)"Fl_Browser_make_visible", _wrap_Fl_Browser_make_visible, METH_VARARGS, (char *)"Fl_Browser_make_visible(Fl_Browser self, int line)"},
	 { (char *)"Fl_Browser_icon", _wrap_Fl_Browser_icon, METH_VARARGS, (char *)"\n"
		"icon(int line, Fl_Image icon)\n"
		"Fl_Browser_icon(Fl_Browser self, int line) -> Fl_Image\n"
		""},
	 { (char *)"Fl_Browser_remove_icon", _wrap_Fl_Browser_remove_icon, METH_VARARGS, (char *)"Fl_Browser_remove_icon(Fl_Browser self, int line)"},
	 { (char *)"Fl_Browser_replace", _wrap_Fl_Browser_replace, METH_VARARGS, (char *)"Fl_Browser_replace(Fl_Browser self, int a, char const * b)"},
	 { (char *)"Fl_Browser_display", _wrap_Fl_Browser_display, METH_VARARGS, (char *)"Fl_Browser_display(Fl_Browser self, int line, int val=1)"},
	 { (char *)"Fl_Browser_add", _wrap_Fl_Browser_add, METH_VARARGS, (char *)"Fl_Browser_add(Fl_Browser self, char const * text, PyObject * data=None)"},
	 { (char *)"Fl_Browser_insert", _wrap_Fl_Browser_insert, METH_VARARGS, (char *)"Fl_Browser_insert(Fl_Browser self, int index, char const * text, PyObject * data=None)"},
	 { (char *)"Fl_Browser_get_data", _wrap_Fl_Browser_get_data, METH_VARARGS, (char *)"Fl_Browser_get_data(Fl_Browser self, int index) -> PyObject *"},
	 { (char *)"Fl_Browser_data", _wrap_Fl_Browser_data, METH_VARARGS, (char *)"Fl_Browser_data(Fl_Browser self, int index, PyObject * data=None) -> PyObject *"},
	 { (char *)"Fl_Browser_column_widths", _wrap_Fl_Browser_column_widths, METH_VARARGS, (char *)"\n"
		"column_widths() -> int const\n"
		"Fl_Browser_column_widths(Fl_Browser self, PyObject * widths)\n"
		""},
	 { (char *)"disown_Fl_Browser", _wrap_disown_Fl_Browser, METH_VARARGS, NULL},
	 { (char *)"Fl_Browser_draw", _wrap_Fl_Browser_draw, METH_VARARGS, (char *)"Fl_Browser_draw(Fl_Browser self)"},
	 { (char *)"Fl_Browser_item_quick_height", _wrap_Fl_Browser_item_quick_height, METH_VARARGS, (char *)"Fl_Browser_item_quick_height(Fl_Browser self, void * item) -> int"},
	 { (char *)"Fl_Browser_full_width", _wrap_Fl_Browser_full_width, METH_VARARGS, (char *)"Fl_Browser_full_width(Fl_Browser self) -> int"},
	 { (char *)"Fl_Browser_swigregister", Fl_Browser_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_File_Browser", _wrap_new_Fl_File_Browser, METH_VARARGS, (char *)"new_Fl_File_Browser(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_File_Browser"},
	 { (char *)"Fl_File_Browser_iconsize", _wrap_Fl_File_Browser_iconsize, METH_VARARGS, (char *)"\n"
		"iconsize() -> uchar\n"
		"Fl_File_Browser_iconsize(Fl_File_Browser self, uchar s)\n"
		""},
	 { (char *)"Fl_File_Browser_filter", _wrap_Fl_File_Browser_filter, METH_VARARGS, (char *)"\n"
		"filter(char const * pattern)\n"
		"Fl_File_Browser_filter(Fl_File_Browser self) -> char const *\n"
		""},
	 { (char *)"Fl_File_Browser_textsize", _wrap_Fl_File_Browser_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_File_Browser_textsize(Fl_File_Browser self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_File_Browser_filetype", _wrap_Fl_File_Browser_filetype, METH_VARARGS, (char *)"\n"
		"filetype() -> int\n"
		"Fl_File_Browser_filetype(Fl_File_Browser self, int t)\n"
		""},
	 { (char *)"Fl_File_Browser_load", _wrap_Fl_File_Browser_load, METH_VARARGS, (char *)"Fl_File_Browser_load(Fl_File_Browser self, PyObject * dObj, PyObject * sObj) -> int"},
	 { (char *)"delete_Fl_File_Browser", _wrap_delete_Fl_File_Browser, METH_VARARGS, (char *)"delete_Fl_File_Browser(Fl_File_Browser self)"},
	 { (char *)"disown_Fl_File_Browser", _wrap_disown_Fl_File_Browser, METH_VARARGS, NULL},
	 { (char *)"Fl_File_Browser_draw", _wrap_Fl_File_Browser_draw, METH_VARARGS, (char *)"Fl_File_Browser_draw(Fl_File_Browser self)"},
	 { (char *)"Fl_File_Browser_item_first", _wrap_Fl_File_Browser_item_first, METH_VARARGS, (char *)"Fl_File_Browser_item_first(Fl_File_Browser self) -> void *"},
	 { (char *)"Fl_File_Browser_item_next", _wrap_Fl_File_Browser_item_next, METH_VARARGS, (char *)"Fl_File_Browser_item_next(Fl_File_Browser self, void * item) -> void *"},
	 { (char *)"Fl_File_Browser_item_prev", _wrap_Fl_File_Browser_item_prev, METH_VARARGS, (char *)"Fl_File_Browser_item_prev(Fl_File_Browser self, void * item) -> void *"},
	 { (char *)"Fl_File_Browser_item_last", _wrap_Fl_File_Browser_item_last, METH_VARARGS, (char *)"Fl_File_Browser_item_last(Fl_File_Browser self) -> void *"},
	 { (char *)"Fl_File_Browser_item_height", _wrap_Fl_File_Browser_item_height, METH_VARARGS, (char *)"Fl_File_Browser_item_height(Fl_File_Browser self, void * item) -> int"},
	 { (char *)"Fl_File_Browser_item_width", _wrap_Fl_File_Browser_item_width, METH_VARARGS, (char *)"Fl_File_Browser_item_width(Fl_File_Browser self, void * item) -> int"},
	 { (char *)"Fl_File_Browser_item_quick_height", _wrap_Fl_File_Browser_item_quick_height, METH_VARARGS, (char *)"Fl_File_Browser_item_quick_height(Fl_File_Browser self, void * item) -> int"},
	 { (char *)"Fl_File_Browser_item_draw", _wrap_Fl_File_Browser_item_draw, METH_VARARGS, (char *)"Fl_File_Browser_item_draw(Fl_File_Browser self, void * item, int X, int Y, int W, int H)"},
	 { (char *)"Fl_File_Browser_item_text", _wrap_Fl_File_Browser_item_text, METH_VARARGS, (char *)"Fl_File_Browser_item_text(Fl_File_Browser self, void * item) -> char const *"},
	 { (char *)"Fl_File_Browser_item_swap", _wrap_Fl_File_Browser_item_swap, METH_VARARGS, (char *)"Fl_File_Browser_item_swap(Fl_File_Browser self, void * a, void * b)"},
	 { (char *)"Fl_File_Browser_item_at", _wrap_Fl_File_Browser_item_at, METH_VARARGS, (char *)"Fl_File_Browser_item_at(Fl_File_Browser self, int line) -> void *"},
	 { (char *)"Fl_File_Browser_full_width", _wrap_Fl_File_Browser_full_width, METH_VARARGS, (char *)"Fl_File_Browser_full_width(Fl_File_Browser self) -> int"},
	 { (char *)"Fl_File_Browser_full_height", _wrap_Fl_File_Browser_full_height, METH_VARARGS, (char *)"Fl_File_Browser_full_height(Fl_File_Browser self) -> int"},
	 { (char *)"Fl_File_Browser_incr_height", _wrap_Fl_File_Browser_incr_height, METH_VARARGS, (char *)"Fl_File_Browser_incr_height(Fl_File_Browser self) -> int"},
	 { (char *)"Fl_File_Browser_item_select", _wrap_Fl_File_Browser_item_select, METH_VARARGS, (char *)"Fl_File_Browser_item_select(Fl_File_Browser self, void * item, int val)"},
	 { (char *)"Fl_File_Browser_item_selected", _wrap_Fl_File_Browser_item_selected, METH_VARARGS, (char *)"Fl_File_Browser_item_selected(Fl_File_Browser self, void * item) -> int"},
	 { (char *)"Fl_File_Browser_swigregister", Fl_File_Browser_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_File_Icon", _wrap_new_Fl_File_Icon, METH_VARARGS, (char *)"new_Fl_File_Icon(char const * p, int t, int nd=0, short * d=None) -> Fl_File_Icon"},
	 { (char *)"delete_Fl_File_Icon", _wrap_delete_Fl_File_Icon, METH_VARARGS, (char *)"delete_Fl_File_Icon(Fl_File_Icon self)"},
	 { (char *)"Fl_File_Icon_add", _wrap_Fl_File_Icon_add, METH_VARARGS, (char *)"Fl_File_Icon_add(Fl_File_Icon self, short d) -> short *"},
	 { (char *)"Fl_File_Icon_add_color", _wrap_Fl_File_Icon_add_color, METH_VARARGS, (char *)"Fl_File_Icon_add_color(Fl_File_Icon self, Fl_Color c) -> short *"},
	 { (char *)"Fl_File_Icon_add_vertex", _wrap_Fl_File_Icon_add_vertex, METH_VARARGS, (char *)"\n"
		"add_vertex(int x, int y) -> short\n"
		"Fl_File_Icon_add_vertex(Fl_File_Icon self, float x, float y) -> short *\n"
		""},
	 { (char *)"Fl_File_Icon_clear", _wrap_Fl_File_Icon_clear, METH_VARARGS, (char *)"Fl_File_Icon_clear(Fl_File_Icon self)"},
	 { (char *)"Fl_File_Icon_draw", _wrap_Fl_File_Icon_draw, METH_VARARGS, (char *)"Fl_File_Icon_draw(Fl_File_Icon self, int x, int y, int w, int h, Fl_Color ic, int active=1)"},
	 { (char *)"Fl_File_Icon_label", _wrap_Fl_File_Icon_label, METH_VARARGS, (char *)"Fl_File_Icon_label(Fl_File_Icon self, Fl_Widget w)"},
	 { (char *)"Fl_File_Icon_labeltype", _wrap_Fl_File_Icon_labeltype, METH_VARARGS, (char *)"Fl_File_Icon_labeltype(Fl_Label o, int x, int y, int w, int h, Fl_Align a)"},
	 { (char *)"Fl_File_Icon_load", _wrap_Fl_File_Icon_load, METH_VARARGS, (char *)"Fl_File_Icon_load(Fl_File_Icon self, char const * f)"},
	 { (char *)"Fl_File_Icon_load_fti", _wrap_Fl_File_Icon_load_fti, METH_VARARGS, (char *)"Fl_File_Icon_load_fti(Fl_File_Icon self, char const * fti) -> int"},
	 { (char *)"Fl_File_Icon_load_image", _wrap_Fl_File_Icon_load_image, METH_VARARGS, (char *)"Fl_File_Icon_load_image(Fl_File_Icon self, char const * i) -> int"},
	 { (char *)"Fl_File_Icon_next", _wrap_Fl_File_Icon_next, METH_VARARGS, (char *)"Fl_File_Icon_next(Fl_File_Icon self) -> Fl_File_Icon"},
	 { (char *)"Fl_File_Icon_pattern", _wrap_Fl_File_Icon_pattern, METH_VARARGS, (char *)"Fl_File_Icon_pattern(Fl_File_Icon self) -> char const *"},
	 { (char *)"Fl_File_Icon_size", _wrap_Fl_File_Icon_size, METH_VARARGS, (char *)"Fl_File_Icon_size(Fl_File_Icon self) -> int"},
	 { (char *)"Fl_File_Icon_type", _wrap_Fl_File_Icon_type, METH_VARARGS, (char *)"Fl_File_Icon_type(Fl_File_Icon self) -> int"},
	 { (char *)"Fl_File_Icon_value", _wrap_Fl_File_Icon_value, METH_VARARGS, (char *)"Fl_File_Icon_value(Fl_File_Icon self) -> short *"},
	 { (char *)"Fl_File_Icon_find", _wrap_Fl_File_Icon_find, METH_VARARGS, (char *)"Fl_File_Icon_find(char const * filename, int filetype=ANY) -> Fl_File_Icon"},
	 { (char *)"Fl_File_Icon_first", _wrap_Fl_File_Icon_first, METH_VARARGS, (char *)"Fl_File_Icon_first() -> Fl_File_Icon"},
	 { (char *)"Fl_File_Icon_load_system_icons", _wrap_Fl_File_Icon_load_system_icons, METH_VARARGS, (char *)"Fl_File_Icon_load_system_icons()"},
	 { (char *)"Fl_File_Icon_swigregister", Fl_File_Icon_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_File_Chooser", _wrap_new_Fl_File_Chooser, METH_VARARGS, (char *)"new_Fl_File_Chooser(char const * d, char const * p, int t, char const * title) -> Fl_File_Chooser"},
	 { (char *)"delete_Fl_File_Chooser", _wrap_delete_Fl_File_Chooser, METH_VARARGS, (char *)"delete_Fl_File_Chooser(Fl_File_Chooser self)"},
	 { (char *)"Fl_File_Chooser_color", _wrap_Fl_File_Chooser_color, METH_VARARGS, (char *)"\n"
		"color(Fl_Color c)\n"
		"Fl_File_Chooser_color(Fl_File_Chooser self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_File_Chooser_count", _wrap_Fl_File_Chooser_count, METH_VARARGS, (char *)"Fl_File_Chooser_count(Fl_File_Chooser self) -> int"},
	 { (char *)"Fl_File_Chooser_directory", _wrap_Fl_File_Chooser_directory, METH_VARARGS, (char *)"\n"
		"directory(char const * d)\n"
		"Fl_File_Chooser_directory(Fl_File_Chooser self) -> char *\n"
		""},
	 { (char *)"Fl_File_Chooser_filter", _wrap_Fl_File_Chooser_filter, METH_VARARGS, (char *)"\n"
		"filter(char const * p)\n"
		"Fl_File_Chooser_filter(Fl_File_Chooser self) -> char const *\n"
		""},
	 { (char *)"Fl_File_Chooser_filter_value", _wrap_Fl_File_Chooser_filter_value, METH_VARARGS, (char *)"\n"
		"filter_value() -> int\n"
		"Fl_File_Chooser_filter_value(Fl_File_Chooser self, int f)\n"
		""},
	 { (char *)"Fl_File_Chooser_hide", _wrap_Fl_File_Chooser_hide, METH_VARARGS, (char *)"Fl_File_Chooser_hide(Fl_File_Chooser self)"},
	 { (char *)"Fl_File_Chooser_iconsize", _wrap_Fl_File_Chooser_iconsize, METH_VARARGS, (char *)"\n"
		"iconsize(uchar s)\n"
		"Fl_File_Chooser_iconsize(Fl_File_Chooser self) -> uchar\n"
		""},
	 { (char *)"Fl_File_Chooser_label", _wrap_Fl_File_Chooser_label, METH_VARARGS, (char *)"\n"
		"label(char const * l)\n"
		"Fl_File_Chooser_label(Fl_File_Chooser self) -> char const *\n"
		""},
	 { (char *)"Fl_File_Chooser_ok_label", _wrap_Fl_File_Chooser_ok_label, METH_VARARGS, (char *)"\n"
		"ok_label(char const * l)\n"
		"Fl_File_Chooser_ok_label(Fl_File_Chooser self) -> char const *\n"
		""},
	 { (char *)"Fl_File_Chooser_preview", _wrap_Fl_File_Chooser_preview, METH_VARARGS, (char *)"\n"
		"preview(int e)\n"
		"Fl_File_Chooser_preview(Fl_File_Chooser self) -> int\n"
		""},
	 { (char *)"Fl_File_Chooser_rescan", _wrap_Fl_File_Chooser_rescan, METH_VARARGS, (char *)"Fl_File_Chooser_rescan(Fl_File_Chooser self)"},
	 { (char *)"Fl_File_Chooser_show", _wrap_Fl_File_Chooser_show, METH_VARARGS, (char *)"Fl_File_Chooser_show(Fl_File_Chooser self)"},
	 { (char *)"Fl_File_Chooser_shown", _wrap_Fl_File_Chooser_shown, METH_VARARGS, (char *)"Fl_File_Chooser_shown(Fl_File_Chooser self) -> int"},
	 { (char *)"Fl_File_Chooser_textcolor", _wrap_Fl_File_Chooser_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor(Fl_Color c)\n"
		"Fl_File_Chooser_textcolor(Fl_File_Chooser self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_File_Chooser_textfont", _wrap_Fl_File_Chooser_textfont, METH_VARARGS, (char *)"\n"
		"textfont(Fl_Font f)\n"
		"Fl_File_Chooser_textfont(Fl_File_Chooser self) -> Fl_Font\n"
		""},
	 { (char *)"Fl_File_Chooser_textsize", _wrap_Fl_File_Chooser_textsize, METH_VARARGS, (char *)"\n"
		"textsize(Fl_Fontsize s)\n"
		"Fl_File_Chooser_textsize(Fl_File_Chooser self) -> Fl_Fontsize\n"
		""},
	 { (char *)"Fl_File_Chooser_type", _wrap_Fl_File_Chooser_type, METH_VARARGS, (char *)"\n"
		"type(int t)\n"
		"Fl_File_Chooser_type(Fl_File_Chooser self) -> int\n"
		""},
	 { (char *)"Fl_File_Chooser_user_data", _wrap_Fl_File_Chooser_user_data, METH_VARARGS, (char *)"\n"
		"user_data()\n"
		"Fl_File_Chooser_user_data(Fl_File_Chooser self, void * d)\n"
		""},
	 { (char *)"Fl_File_Chooser_value", _wrap_Fl_File_Chooser_value, METH_VARARGS, (char *)"\n"
		"value(int f=1) -> char const\n"
		"Fl_File_Chooser_value(Fl_File_Chooser self, char const * filename)\n"
		""},
	 { (char *)"Fl_File_Chooser_visible", _wrap_Fl_File_Chooser_visible, METH_VARARGS, (char *)"Fl_File_Chooser_visible(Fl_File_Chooser self) -> int"},
	 { (char *)"Fl_File_Chooser_add_extra", _wrap_Fl_File_Chooser_add_extra, METH_VARARGS, (char *)"Fl_File_Chooser_add_extra(Fl_File_Chooser self, Fl_Widget gr) -> Fl_Widget"},
	 { (char *)"Fl_File_Chooser_callback", _wrap_Fl_File_Chooser_callback, METH_VARARGS, (char *)"\n"
		"callback(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"
		""},
	 { (char *)"Fl_File_Chooser_swigregister", Fl_File_Chooser_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_dir_chooser", _wrap_fl_dir_chooser, METH_VARARGS, (char *)"fl_dir_chooser(char const * message, char const * fname, int relative=0) -> char *"},
	 { (char *)"fl_file_chooser", _wrap_fl_file_chooser, METH_VARARGS, (char *)"fl_file_chooser(char const * message, char const * pat, char const * fname, int relative=0) -> char *"},
	 { (char *)"fl_file_chooser_callback", _wrap_fl_file_chooser_callback, METH_VARARGS, (char *)"fl_file_chooser_callback(void (*)(char const *) cb)"},
	 { (char *)"fl_file_chooser_ok_label", _wrap_fl_file_chooser_ok_label, METH_VARARGS, (char *)"fl_file_chooser_ok_label(char const * l)"},
	 { (char *)"Fl_call_screen_init", _wrap_Fl_call_screen_init, METH_VARARGS, (char *)"Fl_call_screen_init()"},
	 { (char *)"Fl_option", _wrap_Fl_option, METH_VARARGS, (char *)"\n"
		"option(Fl::Fl_Option opt) -> bool\n"
		"Fl_option(Fl::Fl_Option opt, bool val)\n"
		""},
	 { (char *)"Fl_add_awake_handler_", _wrap_Fl_add_awake_handler_, METH_VARARGS, (char *)"Fl_add_awake_handler_(Fl_Awake_Handler arg1, void * arg2) -> int"},
	 { (char *)"Fl_version", _wrap_Fl_version, METH_VARARGS, (char *)"Fl_version() -> double"},
	 { (char *)"Fl_api_version", _wrap_Fl_api_version, METH_VARARGS, (char *)"Fl_api_version() -> int"},
	 { (char *)"Fl_abi_version", _wrap_Fl_abi_version, METH_VARARGS, (char *)"Fl_abi_version() -> int"},
	 { (char *)"Fl_abi_check", _wrap_Fl_abi_check, METH_VARARGS, (char *)"Fl_abi_check(int const val=(1*10000+3*100)) -> int"},
	 { (char *)"Fl_arg", _wrap_Fl_arg, METH_VARARGS, (char *)"Fl_arg(int argc, char ** argv, int & i) -> int"},
	 { (char *)"Fl_args", _wrap_Fl_args, METH_VARARGS, (char *)"\n"
		"args(int argc, char ** argv, int & i, Fl_Args_Handler cb=0) -> int\n"
		"Fl_args(int argc, char ** argv)\n"
		""},
	 { (char *)"Fl_display", _wrap_Fl_display, METH_VARARGS, (char *)"Fl_display(char const * arg1)"},
	 { (char *)"Fl_visual", _wrap_Fl_visual, METH_VARARGS, (char *)"Fl_visual(int arg1) -> int"},
	 { (char *)"Fl_own_colormap", _wrap_Fl_own_colormap, METH_VARARGS, (char *)"Fl_own_colormap()"},
	 { (char *)"Fl_get_system_colors", _wrap_Fl_get_system_colors, METH_VARARGS, (char *)"Fl_get_system_colors()"},
	 { (char *)"Fl_foreground", _wrap_Fl_foreground, METH_VARARGS, (char *)"Fl_foreground(uchar arg1, uchar arg2, uchar arg3)"},
	 { (char *)"Fl_background", _wrap_Fl_background, METH_VARARGS, (char *)"Fl_background(uchar arg1, uchar arg2, uchar arg3)"},
	 { (char *)"Fl_background2", _wrap_Fl_background2, METH_VARARGS, (char *)"Fl_background2(uchar arg1, uchar arg2, uchar arg3)"},
	 { (char *)"Fl_scheme", _wrap_Fl_scheme, METH_VARARGS, (char *)"\n"
		"scheme(char const * name) -> int\n"
		"Fl_scheme() -> char const *\n"
		""},
	 { (char *)"Fl_is_scheme", _wrap_Fl_is_scheme, METH_VARARGS, (char *)"Fl_is_scheme(char const * name) -> int"},
	 { (char *)"Fl_reload_scheme", _wrap_Fl_reload_scheme, METH_VARARGS, (char *)"Fl_reload_scheme() -> int"},
	 { (char *)"Fl_scrollbar_size", _wrap_Fl_scrollbar_size, METH_VARARGS, (char *)"\n"
		"scrollbar_size() -> int\n"
		"Fl_scrollbar_size(int W)\n"
		""},
	 { (char *)"Fl_wait", _wrap_Fl_wait, METH_VARARGS, (char *)"\n"
		"wait() -> int\n"
		"Fl_wait(double time) -> double\n"
		""},
	 { (char *)"Fl_check", _wrap_Fl_check, METH_VARARGS, (char *)"Fl_check() -> int"},
	 { (char *)"Fl_ready", _wrap_Fl_ready, METH_VARARGS, (char *)"Fl_ready() -> int"},
	 { (char *)"Fl_run", _wrap_Fl_run, METH_VARARGS, (char *)"Fl_run() -> int"},
	 { (char *)"Fl_readqueue", _wrap_Fl_readqueue, METH_VARARGS, (char *)"Fl_readqueue() -> Fl_Widget"},
	 { (char *)"Fl_has_timeout", _wrap_Fl_has_timeout, METH_VARARGS, (char *)"Fl_has_timeout(Fl_Timeout_Handler arg1, void * arg2=None) -> int"},
	 { (char *)"Fl_add_idle", _wrap_Fl_add_idle, METH_VARARGS, (char *)"Fl_add_idle(Fl_Idle_Handler cb, void * data=None)"},
	 { (char *)"Fl_has_idle", _wrap_Fl_has_idle, METH_VARARGS, (char *)"Fl_has_idle(Fl_Idle_Handler cb, void * data=None) -> int"},
	 { (char *)"Fl_remove_idle", _wrap_Fl_remove_idle, METH_VARARGS, (char *)"Fl_remove_idle(Fl_Idle_Handler cb, void * data=None)"},
	 { (char *)"Fl_damage", _wrap_Fl_damage, METH_VARARGS, (char *)"\n"
		"damage(int d)\n"
		"Fl_damage() -> int\n"
		""},
	 { (char *)"Fl_redraw", _wrap_Fl_redraw, METH_VARARGS, (char *)"Fl_redraw()"},
	 { (char *)"Fl_flush", _wrap_Fl_flush, METH_VARARGS, (char *)"Fl_flush()"},
	 { (char *)"Fl_first_window", _wrap_Fl_first_window, METH_VARARGS, (char *)"\n"
		"first_window() -> Fl_Window\n"
		"Fl_first_window(Fl_Window arg1)\n"
		""},
	 { (char *)"Fl_next_window", _wrap_Fl_next_window, METH_VARARGS, (char *)"Fl_next_window(Fl_Window arg1) -> Fl_Window"},
	 { (char *)"Fl_modal", _wrap_Fl_modal, METH_VARARGS, (char *)"Fl_modal() -> Fl_Window"},
	 { (char *)"Fl_grab", _wrap_Fl_grab, METH_VARARGS, (char *)"\n"
		"grab() -> Fl_Window\n"
		"Fl_grab(Fl_Window arg1)\n"
		""},
	 { (char *)"Fl_event", _wrap_Fl_event, METH_VARARGS, (char *)"Fl_event() -> int"},
	 { (char *)"Fl_event_x", _wrap_Fl_event_x, METH_VARARGS, (char *)"Fl_event_x() -> int"},
	 { (char *)"Fl_event_y", _wrap_Fl_event_y, METH_VARARGS, (char *)"Fl_event_y() -> int"},
	 { (char *)"Fl_event_x_root", _wrap_Fl_event_x_root, METH_VARARGS, (char *)"Fl_event_x_root() -> int"},
	 { (char *)"Fl_event_y_root", _wrap_Fl_event_y_root, METH_VARARGS, (char *)"Fl_event_y_root() -> int"},
	 { (char *)"Fl_event_dx", _wrap_Fl_event_dx, METH_VARARGS, (char *)"Fl_event_dx() -> int"},
	 { (char *)"Fl_event_dy", _wrap_Fl_event_dy, METH_VARARGS, (char *)"Fl_event_dy() -> int"},
	 { (char *)"Fl_get_mouse", _wrap_Fl_get_mouse, METH_VARARGS, (char *)"Fl_get_mouse(int & arg1, int & arg2)"},
	 { (char *)"Fl_event_clicks", _wrap_Fl_event_clicks, METH_VARARGS, (char *)"\n"
		"event_clicks() -> int\n"
		"Fl_event_clicks(int i)\n"
		""},
	 { (char *)"Fl_event_is_click", _wrap_Fl_event_is_click, METH_VARARGS, (char *)"\n"
		"event_is_click() -> int\n"
		"Fl_event_is_click(int i)\n"
		""},
	 { (char *)"Fl_event_button", _wrap_Fl_event_button, METH_VARARGS, (char *)"Fl_event_button() -> int"},
	 { (char *)"Fl_event_state", _wrap_Fl_event_state, METH_VARARGS, (char *)"\n"
		"event_state() -> int\n"
		"Fl_event_state(int mask) -> int\n"
		""},
	 { (char *)"Fl_event_original_key", _wrap_Fl_event_original_key, METH_VARARGS, (char *)"Fl_event_original_key() -> int"},
	 { (char *)"Fl_event_key", _wrap_Fl_event_key, METH_VARARGS, (char *)"\n"
		"event_key() -> int\n"
		"Fl_event_key(int key) -> int\n"
		""},
	 { (char *)"Fl_get_key", _wrap_Fl_get_key, METH_VARARGS, (char *)"Fl_get_key(int key) -> int"},
	 { (char *)"Fl_event_text", _wrap_Fl_event_text, METH_VARARGS, (char *)"Fl_event_text() -> char const *"},
	 { (char *)"Fl_event_length", _wrap_Fl_event_length, METH_VARARGS, (char *)"Fl_event_length() -> int"},
	 { (char *)"Fl_event_clipboard", _wrap_Fl_event_clipboard, METH_VARARGS, (char *)"Fl_event_clipboard() -> void *"},
	 { (char *)"Fl_event_clipboard_type", _wrap_Fl_event_clipboard_type, METH_VARARGS, (char *)"Fl_event_clipboard_type() -> char const *"},
	 { (char *)"Fl_compose", _wrap_Fl_compose, METH_VARARGS, (char *)"Fl_compose(int & _del) -> int"},
	 { (char *)"Fl_compose_reset", _wrap_Fl_compose_reset, METH_VARARGS, (char *)"Fl_compose_reset()"},
	 { (char *)"Fl_event_inside", _wrap_Fl_event_inside, METH_VARARGS, (char *)"\n"
		"event_inside(int arg1, int arg2, int arg3, int arg4) -> int\n"
		"Fl_event_inside(Fl_Widget arg1) -> int\n"
		""},
	 { (char *)"Fl_test_shortcut", _wrap_Fl_test_shortcut, METH_VARARGS, (char *)"Fl_test_shortcut(Fl_Shortcut arg1) -> int"},
	 { (char *)"Fl_enable_im", _wrap_Fl_enable_im, METH_VARARGS, (char *)"Fl_enable_im()"},
	 { (char *)"Fl_disable_im", _wrap_Fl_disable_im, METH_VARARGS, (char *)"Fl_disable_im()"},
	 { (char *)"Fl_handle", _wrap_Fl_handle, METH_VARARGS, (char *)"Fl_handle(int arg1, Fl_Window arg2) -> int"},
	 { (char *)"Fl_handle_", _wrap_Fl_handle_, METH_VARARGS, (char *)"Fl_handle_(int arg1, Fl_Window arg2) -> int"},
	 { (char *)"Fl_belowmouse", _wrap_Fl_belowmouse, METH_VARARGS, (char *)"\n"
		"belowmouse() -> Fl_Widget\n"
		"Fl_belowmouse(Fl_Widget arg1)\n"
		""},
	 { (char *)"Fl_pushed", _wrap_Fl_pushed, METH_VARARGS, (char *)"\n"
		"pushed() -> Fl_Widget\n"
		"Fl_pushed(Fl_Widget arg1)\n"
		""},
	 { (char *)"Fl_focus", _wrap_Fl_focus, METH_VARARGS, (char *)"\n"
		"focus() -> Fl_Widget\n"
		"Fl_focus(Fl_Widget arg1)\n"
		""},
	 { (char *)"Fl_add_system_handler", _wrap_Fl_add_system_handler, METH_VARARGS, (char *)"Fl_add_system_handler(Fl_System_Handler h, void * data)"},
	 { (char *)"Fl_remove_system_handler", _wrap_Fl_remove_system_handler, METH_VARARGS, (char *)"Fl_remove_system_handler(Fl_System_Handler h)"},
	 { (char *)"Fl_event_dispatch", _wrap_Fl_event_dispatch, METH_VARARGS, (char *)"\n"
		"event_dispatch(Fl_Event_Dispatch d)\n"
		"Fl_event_dispatch() -> Fl_Event_Dispatch\n"
		""},
	 { (char *)"Fl_copy", _wrap_Fl_copy, METH_VARARGS, (char *)"\n"
		"copy(char const * stuff, int len, int destination, char const * type)\n"
		"Fl_copy(char const * stuff, int len, int destination=0)\n"
		""},
	 { (char *)"Fl_add_clipboard_notify", _wrap_Fl_add_clipboard_notify, METH_VARARGS, (char *)"Fl_add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void * data=None)"},
	 { (char *)"Fl_remove_clipboard_notify", _wrap_Fl_remove_clipboard_notify, METH_VARARGS, (char *)"Fl_remove_clipboard_notify(Fl_Clipboard_Notify_Handler h)"},
	 { (char *)"Fl_clipboard_contains", _wrap_Fl_clipboard_contains, METH_VARARGS, (char *)"Fl_clipboard_contains(char const * type) -> int"},
	 { (char *)"Fl_dnd", _wrap_Fl_dnd, METH_VARARGS, (char *)"Fl_dnd() -> int"},
	 { (char *)"Fl_selection_owner", _wrap_Fl_selection_owner, METH_VARARGS, (char *)"\n"
		"selection_owner() -> Fl_Widget\n"
		"Fl_selection_owner(Fl_Widget arg1)\n"
		""},
	 { (char *)"Fl_selection", _wrap_Fl_selection, METH_VARARGS, (char *)"Fl_selection(Fl_Widget owner, char const * arg2, int len)"},
	 { (char *)"Fl_paste", _wrap_Fl_paste, METH_VARARGS, (char *)"\n"
		"paste(Fl_Widget receiver, int source, char const * type)\n"
		"paste(Fl_Widget receiver, int source)\n"
		"Fl_paste(Fl_Widget receiver)\n"
		""},
	 { (char *)"Fl_x", _wrap_Fl_x, METH_VARARGS, (char *)"Fl_x() -> int"},
	 { (char *)"Fl_y", _wrap_Fl_y, METH_VARARGS, (char *)"Fl_y() -> int"},
	 { (char *)"Fl_w", _wrap_Fl_w, METH_VARARGS, (char *)"Fl_w() -> int"},
	 { (char *)"Fl_h", _wrap_Fl_h, METH_VARARGS, (char *)"Fl_h() -> int"},
	 { (char *)"Fl_screen_count", _wrap_Fl_screen_count, METH_VARARGS, (char *)"Fl_screen_count() -> int"},
	 { (char *)"Fl_screen_xywh", _wrap_Fl_screen_xywh, METH_VARARGS, (char *)"\n"
		"screen_xywh(int & X, int & Y, int & W, int & H)\n"
		"screen_xywh(int & X, int & Y, int & W, int & H, int mx, int my)\n"
		"screen_xywh(int & X, int & Y, int & W, int & H, int n)\n"
		"Fl_screen_xywh(int & X, int & Y, int & W, int & H, int mx, int my, int mw, int mh)\n"
		""},
	 { (char *)"Fl_screen_num", _wrap_Fl_screen_num, METH_VARARGS, (char *)"\n"
		"screen_num(int x, int y) -> int\n"
		"Fl_screen_num(int x, int y, int w, int h) -> int\n"
		""},
	 { (char *)"Fl_screen_dpi", _wrap_Fl_screen_dpi, METH_VARARGS, (char *)"Fl_screen_dpi(float & h, float & v, int n=0)"},
	 { (char *)"Fl_screen_work_area", _wrap_Fl_screen_work_area, METH_VARARGS, (char *)"\n"
		"screen_work_area(int & X, int & Y, int & W, int & H, int mx, int my)\n"
		"screen_work_area(int & X, int & Y, int & W, int & H, int n)\n"
		"Fl_screen_work_area(int & X, int & Y, int & W, int & H)\n"
		""},
	 { (char *)"Fl_set_color", _wrap_Fl_set_color, METH_VARARGS, (char *)"\n"
		"set_color(Fl_Color arg1, uchar arg2, uchar arg3, uchar arg4)\n"
		"Fl_set_color(Fl_Color i, unsigned int c)\n"
		""},
	 { (char *)"Fl_get_color", _wrap_Fl_get_color, METH_VARARGS, (char *)"Fl_get_color(Fl_Color i)"},
	 { (char *)"Fl_free_color", _wrap_Fl_free_color, METH_VARARGS, (char *)"Fl_free_color(Fl_Color i, int overlay=0)"},
	 { (char *)"Fl_get_font", _wrap_Fl_get_font, METH_VARARGS, (char *)"Fl_get_font(Fl_Font arg1) -> char const *"},
	 { (char *)"Fl_get_font_name", _wrap_Fl_get_font_name, METH_VARARGS, (char *)"Fl_get_font_name(Fl_Font arg1) -> char const *"},
	 { (char *)"Fl_set_font", _wrap_Fl_set_font, METH_VARARGS, (char *)"\n"
		"set_font(Fl_Font arg1, char const * arg2)\n"
		"Fl_set_font(Fl_Font arg1, Fl_Font arg2)\n"
		""},
	 { (char *)"Fl_set_fonts", _wrap_Fl_set_fonts, METH_VARARGS, (char *)"Fl_set_fonts(char const * arg1=None) -> Fl_Font"},
	 { (char *)"Fl_set_labeltype", _wrap_Fl_set_labeltype, METH_VARARGS, (char *)"Fl_set_labeltype(Fl_Labeltype arg1, Fl_Label_Draw_F * arg2, Fl_Label_Measure_F * arg3)"},
	 { (char *)"Fl_get_boxtype", _wrap_Fl_get_boxtype, METH_VARARGS, (char *)"Fl_get_boxtype(Fl_Boxtype arg1) -> Fl_Box_Draw_F *"},
	 { (char *)"Fl_set_boxtype", _wrap_Fl_set_boxtype, METH_VARARGS, (char *)"\n"
		"set_boxtype(Fl_Boxtype arg1, Fl_Box_Draw_F * arg2, uchar arg3, uchar arg4, uchar arg5, uchar arg6)\n"
		"Fl_set_boxtype(Fl_Boxtype arg1, Fl_Boxtype _from)\n"
		""},
	 { (char *)"Fl_box_dx", _wrap_Fl_box_dx, METH_VARARGS, (char *)"Fl_box_dx(Fl_Boxtype arg1) -> int"},
	 { (char *)"Fl_box_dy", _wrap_Fl_box_dy, METH_VARARGS, (char *)"Fl_box_dy(Fl_Boxtype arg1) -> int"},
	 { (char *)"Fl_box_dw", _wrap_Fl_box_dw, METH_VARARGS, (char *)"Fl_box_dw(Fl_Boxtype arg1) -> int"},
	 { (char *)"Fl_box_dh", _wrap_Fl_box_dh, METH_VARARGS, (char *)"Fl_box_dh(Fl_Boxtype arg1) -> int"},
	 { (char *)"Fl_draw_box_active", _wrap_Fl_draw_box_active, METH_VARARGS, (char *)"Fl_draw_box_active() -> int"},
	 { (char *)"Fl_box_color", _wrap_Fl_box_color, METH_VARARGS, (char *)"Fl_box_color(Fl_Color arg1) -> Fl_Color"},
	 { (char *)"Fl_set_box_color", _wrap_Fl_set_box_color, METH_VARARGS, (char *)"Fl_set_box_color(Fl_Color arg1)"},
	 { (char *)"Fl_set_abort", _wrap_Fl_set_abort, METH_VARARGS, (char *)"Fl_set_abort(Fl_Abort_Handler f)"},
	 { (char *)"Fl_default_atclose", _wrap_Fl_default_atclose, METH_VARARGS, (char *)"Fl_default_atclose(Fl_Window arg1, void * arg2)"},
	 { (char *)"Fl_set_atclose", _wrap_Fl_set_atclose, METH_VARARGS, (char *)"Fl_set_atclose(Fl_Atclose_Handler f)"},
	 { (char *)"Fl_event_shift", _wrap_Fl_event_shift, METH_VARARGS, (char *)"Fl_event_shift() -> int"},
	 { (char *)"Fl_event_ctrl", _wrap_Fl_event_ctrl, METH_VARARGS, (char *)"Fl_event_ctrl() -> int"},
	 { (char *)"Fl_event_command", _wrap_Fl_event_command, METH_VARARGS, (char *)"Fl_event_command() -> int"},
	 { (char *)"Fl_event_alt", _wrap_Fl_event_alt, METH_VARARGS, (char *)"Fl_event_alt() -> int"},
	 { (char *)"Fl_event_buttons", _wrap_Fl_event_buttons, METH_VARARGS, (char *)"Fl_event_buttons() -> int"},
	 { (char *)"Fl_event_button1", _wrap_Fl_event_button1, METH_VARARGS, (char *)"Fl_event_button1() -> int"},
	 { (char *)"Fl_event_button2", _wrap_Fl_event_button2, METH_VARARGS, (char *)"Fl_event_button2() -> int"},
	 { (char *)"Fl_event_button3", _wrap_Fl_event_button3, METH_VARARGS, (char *)"Fl_event_button3() -> int"},
	 { (char *)"Fl_set_idle", _wrap_Fl_set_idle, METH_VARARGS, (char *)"Fl_set_idle(Fl_Old_Idle_Handler cb)"},
	 { (char *)"Fl_release", _wrap_Fl_release, METH_VARARGS, (char *)"Fl_release()"},
	 { (char *)"Fl_visible_focus", _wrap_Fl_visible_focus, METH_VARARGS, (char *)"\n"
		"visible_focus(int v)\n"
		"Fl_visible_focus() -> int\n"
		""},
	 { (char *)"Fl_dnd_text_ops", _wrap_Fl_dnd_text_ops, METH_VARARGS, (char *)"\n"
		"dnd_text_ops(int v)\n"
		"Fl_dnd_text_ops() -> int\n"
		""},
	 { (char *)"Fl_delete_widget", _wrap_Fl_delete_widget, METH_VARARGS, (char *)"Fl_delete_widget(Fl_Widget w)"},
	 { (char *)"Fl_do_widget_deletion", _wrap_Fl_do_widget_deletion, METH_VARARGS, (char *)"Fl_do_widget_deletion()"},
	 { (char *)"Fl_watch_widget_pointer", _wrap_Fl_watch_widget_pointer, METH_VARARGS, (char *)"Fl_watch_widget_pointer(Fl_Widget *& w)"},
	 { (char *)"Fl_release_widget_pointer", _wrap_Fl_release_widget_pointer, METH_VARARGS, (char *)"Fl_release_widget_pointer(Fl_Widget *& w)"},
	 { (char *)"Fl_clear_widget_pointer", _wrap_Fl_clear_widget_pointer, METH_VARARGS, (char *)"Fl_clear_widget_pointer(Fl_Widget w)"},
	 { (char *)"Fl_use_high_res_GL", _wrap_Fl_use_high_res_GL, METH_VARARGS, (char *)"\n"
		"use_high_res_GL(int val)\n"
		"Fl_use_high_res_GL() -> int\n"
		""},
	 { (char *)"Fl_lock", _wrap_Fl_lock, METH_VARARGS, (char *)"Fl_lock()"},
	 { (char *)"Fl_unlock", _wrap_Fl_unlock, METH_VARARGS, (char *)"Fl_unlock()"},
	 { (char *)"Fl_awake", _wrap_Fl_awake, METH_VARARGS, (char *)"\n"
		"awake(Fl_Awake_Handler cb, void * message=None) -> int\n"
		"Fl_awake(void * message=None)\n"
		""},
	 { (char *)"Fl_thread_message", _wrap_Fl_thread_message, METH_VARARGS, (char *)"Fl_thread_message()"},
	 { (char *)"delete_Fl", _wrap_delete_Fl, METH_VARARGS, (char *)"delete_Fl(Fl self)"},
	 { (char *)"Fl_swigregister", Fl_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Widget_Tracker", _wrap_new_Fl_Widget_Tracker, METH_VARARGS, (char *)"new_Fl_Widget_Tracker(Fl_Widget wi) -> Fl_Widget_Tracker"},
	 { (char *)"delete_Fl_Widget_Tracker", _wrap_delete_Fl_Widget_Tracker, METH_VARARGS, (char *)"delete_Fl_Widget_Tracker(Fl_Widget_Tracker self)"},
	 { (char *)"Fl_Widget_Tracker_widget", _wrap_Fl_Widget_Tracker_widget, METH_VARARGS, (char *)"Fl_Widget_Tracker_widget(Fl_Widget_Tracker self) -> Fl_Widget"},
	 { (char *)"Fl_Widget_Tracker_deleted", _wrap_Fl_Widget_Tracker_deleted, METH_VARARGS, (char *)"Fl_Widget_Tracker_deleted(Fl_Widget_Tracker self) -> int"},
	 { (char *)"Fl_Widget_Tracker_exists", _wrap_Fl_Widget_Tracker_exists, METH_VARARGS, (char *)"Fl_Widget_Tracker_exists(Fl_Widget_Tracker self) -> int"},
	 { (char *)"Fl_Widget_Tracker_swigregister", Fl_Widget_Tracker_swigregister, METH_VARARGS, NULL},
	 { (char *)"pyFLTK_controlIdleCallbacks", _wrap_pyFLTK_controlIdleCallbacks, METH_VARARGS, (char *)"pyFLTK_controlIdleCallbacks(int enable)"},
	 { (char *)"pyFLTK_registerDoIdle", registerDoIdle, METH_VARARGS, NULL},
	 { (char *)"Fl_add_timeout", Fl_add_timeout, METH_VARARGS, NULL},
	 { (char *)"Fl_repeat_timeout", Fl_repeat_timeout, METH_VARARGS, NULL},
	 { (char *)"Fl_remove_timeout", Fl_remove_timeout, METH_VARARGS, NULL},
	 { (char *)"Fl_add_fd", Fl_add_fd, METH_VARARGS, NULL},
	 { (char *)"Fl_remove_fd", Fl_remove_fd, METH_VARARGS, NULL},
	 { (char *)"Fl_add_handler", Fl_add_handler, METH_VARARGS, NULL},
	 { (char *)"Fl_remove_handler", Fl_remove_handler, METH_VARARGS, NULL},
	 { (char *)"Fl_add_check", Fl_add_check, METH_VARARGS, NULL},
	 { (char *)"Fl_remove_check", Fl_remove_check, METH_VARARGS, NULL},
	 { (char *)"Fl_get_font_sizes_tmp", Fl_get_font_sizes_tmp, METH_VARARGS, NULL},
	 { (char *)"fl_filename_name", _wrap_fl_filename_name, METH_VARARGS, (char *)"fl_filename_name(char const * filename) -> char const *"},
	 { (char *)"fl_filename_ext", _wrap_fl_filename_ext, METH_VARARGS, (char *)"fl_filename_ext(char const * buf) -> char const *"},
	 { (char *)"fl_filename_match", _wrap_fl_filename_match, METH_VARARGS, (char *)"fl_filename_match(char const * name, char const * pattern) -> int"},
	 { (char *)"fl_filename_isdir", _wrap_fl_filename_isdir, METH_VARARGS, (char *)"fl_filename_isdir(char const * name) -> int"},
	 { (char *)"fl_filename_setext", _wrap_fl_filename_setext, METH_VARARGS, (char *)"\n"
		"fl_filename_setext(char * to, int tolen, char const * ext) -> char\n"
		"fl_filename_setext(char * to, char const * ext) -> char *\n"
		""},
	 { (char *)"fl_filename_expand", _wrap_fl_filename_expand, METH_VARARGS, (char *)"\n"
		"fl_filename_expand(char * to, int tolen, char const * _from) -> int\n"
		"fl_filename_expand(char * to, char const * _from) -> int\n"
		""},
	 { (char *)"fl_filename_absolute", _wrap_fl_filename_absolute, METH_VARARGS, (char *)"\n"
		"fl_filename_absolute(char * to, int tolen, char const * _from) -> int\n"
		"fl_filename_absolute(char * to, char const * _from) -> int\n"
		""},
	 { (char *)"fl_filename_relative", _wrap_fl_filename_relative, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"fl_filename_free_list", _wrap_fl_filename_free_list, METH_VARARGS, (char *)"fl_filename_free_list(dirent *** l, int n)"},
	 { (char *)"fl_open_uri", _wrap_fl_open_uri, METH_VARARGS, (char *)"fl_open_uri(char const * uri, char * msg=(char *) 0, int msglen=0) -> int"},
	 { (char *)"fl_decode_uri", _wrap_fl_decode_uri, METH_VARARGS, (char *)"fl_decode_uri(char * uri)"},
	 { (char *)"Fl_Valuator_bounds", _wrap_Fl_Valuator_bounds, METH_VARARGS, (char *)"Fl_Valuator_bounds(Fl_Valuator self, double a, double b)"},
	 { (char *)"Fl_Valuator_minimum", _wrap_Fl_Valuator_minimum, METH_VARARGS, (char *)"\n"
		"minimum() -> double\n"
		"Fl_Valuator_minimum(Fl_Valuator self, double a)\n"
		""},
	 { (char *)"Fl_Valuator_maximum", _wrap_Fl_Valuator_maximum, METH_VARARGS, (char *)"\n"
		"maximum() -> double\n"
		"Fl_Valuator_maximum(Fl_Valuator self, double a)\n"
		""},
	 { (char *)"Fl_Valuator_range", _wrap_Fl_Valuator_range, METH_VARARGS, (char *)"Fl_Valuator_range(Fl_Valuator self, double a, double b)"},
	 { (char *)"Fl_Valuator_step", _wrap_Fl_Valuator_step, METH_VARARGS, (char *)"\n"
		"step(int a)\n"
		"step(double a, int b)\n"
		"step(double s)\n"
		"Fl_Valuator_step(Fl_Valuator self) -> double\n"
		""},
	 { (char *)"Fl_Valuator_precision", _wrap_Fl_Valuator_precision, METH_VARARGS, (char *)"Fl_Valuator_precision(Fl_Valuator self, int arg2)"},
	 { (char *)"Fl_Valuator_value", _wrap_Fl_Valuator_value, METH_VARARGS, (char *)"\n"
		"value() -> double\n"
		"Fl_Valuator_value(Fl_Valuator self, double arg2) -> int\n"
		""},
	 { (char *)"Fl_Valuator_format", _wrap_Fl_Valuator_format, METH_VARARGS, (char *)"Fl_Valuator_format(Fl_Valuator self, char * format_string) -> int"},
	 { (char *)"Fl_Valuator_round", _wrap_Fl_Valuator_round, METH_VARARGS, (char *)"Fl_Valuator_round(Fl_Valuator self, double arg2) -> double"},
	 { (char *)"Fl_Valuator_clamp", _wrap_Fl_Valuator_clamp, METH_VARARGS, (char *)"Fl_Valuator_clamp(Fl_Valuator self, double arg2) -> double"},
	 { (char *)"Fl_Valuator_increment", _wrap_Fl_Valuator_increment, METH_VARARGS, (char *)"Fl_Valuator_increment(Fl_Valuator self, double arg2, int arg3) -> double"},
	 { (char *)"delete_Fl_Valuator", _wrap_delete_Fl_Valuator, METH_VARARGS, (char *)"delete_Fl_Valuator(Fl_Valuator self)"},
	 { (char *)"Fl_Valuator_swigregister", Fl_Valuator_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Adjuster_draw", _wrap_Fl_Adjuster_draw, METH_VARARGS, (char *)"Fl_Adjuster_draw(Fl_Adjuster self)"},
	 { (char *)"Fl_Adjuster_handle", _wrap_Fl_Adjuster_handle, METH_VARARGS, (char *)"Fl_Adjuster_handle(Fl_Adjuster self, int arg0) -> int"},
	 { (char *)"new_Fl_Adjuster", _wrap_new_Fl_Adjuster, METH_VARARGS, (char *)"new_Fl_Adjuster(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Adjuster"},
	 { (char *)"Fl_Adjuster_soft", _wrap_Fl_Adjuster_soft, METH_VARARGS, (char *)"\n"
		"soft(int s)\n"
		"Fl_Adjuster_soft(Fl_Adjuster self) -> int\n"
		""},
	 { (char *)"delete_Fl_Adjuster", _wrap_delete_Fl_Adjuster, METH_VARARGS, (char *)"delete_Fl_Adjuster(Fl_Adjuster self)"},
	 { (char *)"disown_Fl_Adjuster", _wrap_disown_Fl_Adjuster, METH_VARARGS, NULL},
	 { (char *)"Fl_Adjuster_swigregister", Fl_Adjuster_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_beep", _wrap_fl_beep, METH_VARARGS, (char *)"fl_beep(int type=FL_BEEP_DEFAULT)"},
	 { (char *)"fl_message", _wrap_fl_message, METH_VARARGS, (char *)"fl_message(char const * arg1)"},
	 { (char *)"fl_alert", _wrap_fl_alert, METH_VARARGS, (char *)"fl_alert(char const * arg1)"},
	 { (char *)"fl_ask", _wrap_fl_ask, METH_VARARGS, (char *)"fl_ask(char const * arg1) -> int"},
	 { (char *)"fl_choice", _wrap_fl_choice, METH_VARARGS, (char *)"fl_choice(char const * q, char const * b0, char const * b1, char const * b2) -> int"},
	 { (char *)"fl_message_icon", _wrap_fl_message_icon, METH_VARARGS, (char *)"fl_message_icon() -> Fl_Widget"},
	 { (char *)"fl_message_font", _wrap_fl_message_font, METH_VARARGS, (char *)"fl_message_font(Fl_Font f, Fl_Fontsize s)"},
	 { (char *)"fl_message_hotspot", _wrap_fl_message_hotspot, METH_VARARGS, (char *)"\n"
		"fl_message_hotspot(int enable)\n"
		"fl_message_hotspot() -> int\n"
		""},
	 { (char *)"fl_message_title", _wrap_fl_message_title, METH_VARARGS, (char *)"fl_message_title(char const * title)"},
	 { (char *)"fl_message_title_default", _wrap_fl_message_title_default, METH_VARARGS, (char *)"fl_message_title_default(char const * title)"},
	 { (char *)"fl_input", _wrap_fl_input, METH_VARARGS, (char *)"fl_input(char const * label, char const * deflt=None) -> char const *"},
	 { (char *)"fl_password", _wrap_fl_password, METH_VARARGS, (char *)"fl_password(char const * label, char const * deflt=None) -> char const *"},
	 { (char *)"fl_no_get", _wrap_fl_no_get, METH_VARARGS, (char *)"fl_no_get() -> char const *"},
	 { (char *)"fl_yes_get", _wrap_fl_yes_get, METH_VARARGS, (char *)"fl_yes_get() -> char const *"},
	 { (char *)"fl_ok_get", _wrap_fl_ok_get, METH_VARARGS, (char *)"fl_ok_get() -> char const *"},
	 { (char *)"fl_cancel_get", _wrap_fl_cancel_get, METH_VARARGS, (char *)"fl_cancel_get() -> char const *"},
	 { (char *)"fl_close_get", _wrap_fl_close_get, METH_VARARGS, (char *)"fl_close_get() -> char const *"},
	 { (char *)"fl_no_set", _wrap_fl_no_set, METH_VARARGS, (char *)"fl_no_set(char const * value)"},
	 { (char *)"fl_yes_set", _wrap_fl_yes_set, METH_VARARGS, (char *)"fl_yes_set(char const * value)"},
	 { (char *)"fl_ok_set", _wrap_fl_ok_set, METH_VARARGS, (char *)"fl_ok_set(char const * value)"},
	 { (char *)"fl_cancel_set", _wrap_fl_cancel_set, METH_VARARGS, (char *)"fl_cancel_set(char const * value)"},
	 { (char *)"fl_close_set", _wrap_fl_close_set, METH_VARARGS, (char *)"fl_close_set(char const * value)"},
	 { (char *)"fl_mt_message", _wrap_fl_mt_message, METH_VARARGS, (char *)"fl_mt_message(char const * text)"},
	 { (char *)"fl_mt_alert", _wrap_fl_mt_alert, METH_VARARGS, (char *)"fl_mt_alert(char const * text)"},
	 { (char *)"fl_mt_ask", _wrap_fl_mt_ask, METH_VARARGS, (char *)"fl_mt_ask(char const * text) -> int"},
	 { (char *)"fl_mt_choice", _wrap_fl_mt_choice, METH_VARARGS, (char *)"fl_mt_choice(char const * q, char const * b0, char const * b1, char const * b2) -> int"},
	 { (char *)"fl_mt_input", _wrap_fl_mt_input, METH_VARARGS, (char *)"fl_mt_input(char const * label, char const * deflt=None) -> char const *"},
	 { (char *)"fl_mt_password", _wrap_fl_mt_password, METH_VARARGS, (char *)"fl_mt_password(char const * label, char const * deflt=None) -> char const *"},
	 { (char *)"new_Fl_Bitmap", _wrap_new_Fl_Bitmap, METH_VARARGS, (char *)"new_Fl_Bitmap(PyObject * self, uchar const * bits, int W, int H) -> Fl_Bitmap"},
	 { (char *)"delete_Fl_Bitmap", _wrap_delete_Fl_Bitmap, METH_VARARGS, (char *)"delete_Fl_Bitmap(Fl_Bitmap self)"},
	 { (char *)"Fl_Bitmap_copy", _wrap_Fl_Bitmap_copy, METH_VARARGS, (char *)"\n"
		"copy(int W, int H) -> Fl_Image\n"
		"Fl_Bitmap_copy(Fl_Bitmap self) -> Fl_Image\n"
		""},
	 { (char *)"Fl_Bitmap_draw", _wrap_Fl_Bitmap_draw, METH_VARARGS, (char *)"\n"
		"draw(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"
		""},
	 { (char *)"Fl_Bitmap_label", _wrap_Fl_Bitmap_label, METH_VARARGS, (char *)"\n"
		"label(Fl_Widget w)\n"
		"Fl_Bitmap_label(Fl_Bitmap self, Fl_Menu_Item m)\n"
		""},
	 { (char *)"Fl_Bitmap_uncache", _wrap_Fl_Bitmap_uncache, METH_VARARGS, (char *)"Fl_Bitmap_uncache(Fl_Bitmap self)"},
	 { (char *)"disown_Fl_Bitmap", _wrap_disown_Fl_Bitmap, METH_VARARGS, NULL},
	 { (char *)"Fl_Bitmap_swigregister", Fl_Bitmap_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_BMP_Image", _wrap_new_Fl_BMP_Image, METH_VARARGS, (char *)"new_Fl_BMP_Image(PyObject * self, char const * filename) -> Fl_BMP_Image"},
	 { (char *)"delete_Fl_BMP_Image", _wrap_delete_Fl_BMP_Image, METH_VARARGS, (char *)"delete_Fl_BMP_Image(Fl_BMP_Image self)"},
	 { (char *)"disown_Fl_BMP_Image", _wrap_disown_Fl_BMP_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_BMP_Image_swigregister", Fl_BMP_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Box_draw", _wrap_Fl_Box_draw, METH_VARARGS, (char *)"Fl_Box_draw(Fl_Box self)"},
	 { (char *)"new_Fl_Box", _wrap_new_Fl_Box, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Box_handle", _wrap_Fl_Box_handle, METH_VARARGS, (char *)"Fl_Box_handle(Fl_Box self, int arg0) -> int"},
	 { (char *)"delete_Fl_Box", _wrap_delete_Fl_Box, METH_VARARGS, (char *)"delete_Fl_Box(Fl_Box self)"},
	 { (char *)"disown_Fl_Box", _wrap_disown_Fl_Box, METH_VARARGS, NULL},
	 { (char *)"Fl_Box_swigregister", Fl_Box_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_old_shortcut", _wrap_fl_old_shortcut, METH_VARARGS, (char *)"fl_old_shortcut(char const * arg1) -> Fl_Shortcut"},
	 { (char *)"Fl_Button_draw", _wrap_Fl_Button_draw, METH_VARARGS, (char *)"Fl_Button_draw(Fl_Button self)"},
	 { (char *)"Fl_Button_handle", _wrap_Fl_Button_handle, METH_VARARGS, (char *)"Fl_Button_handle(Fl_Button self, int arg0) -> int"},
	 { (char *)"new_Fl_Button", _wrap_new_Fl_Button, METH_VARARGS, (char *)"new_Fl_Button(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Button"},
	 { (char *)"Fl_Button_value", _wrap_Fl_Button_value, METH_VARARGS, (char *)"\n"
		"value(int v) -> int\n"
		"Fl_Button_value(Fl_Button self) -> char\n"
		""},
	 { (char *)"Fl_Button_set", _wrap_Fl_Button_set, METH_VARARGS, (char *)"Fl_Button_set(Fl_Button self) -> int"},
	 { (char *)"Fl_Button_clear", _wrap_Fl_Button_clear, METH_VARARGS, (char *)"Fl_Button_clear(Fl_Button self) -> int"},
	 { (char *)"Fl_Button_setonly", _wrap_Fl_Button_setonly, METH_VARARGS, (char *)"Fl_Button_setonly(Fl_Button self)"},
	 { (char *)"Fl_Button_down_box", _wrap_Fl_Button_down_box, METH_VARARGS, (char *)"\n"
		"down_box() -> Fl_Boxtype\n"
		"Fl_Button_down_box(Fl_Button self, Fl_Boxtype b)\n"
		""},
	 { (char *)"Fl_Button_shortcut", _wrap_Fl_Button_shortcut, METH_VARARGS, (char *)"\n"
		"shortcut() -> int\n"
		"shortcut(int s)\n"
		"Fl_Button_shortcut(Fl_Button self, char const * s)\n"
		""},
	 { (char *)"Fl_Button_down_color", _wrap_Fl_Button_down_color, METH_VARARGS, (char *)"\n"
		"down_color() -> Fl_Color\n"
		"Fl_Button_down_color(Fl_Button self, unsigned int c)\n"
		""},
	 { (char *)"delete_Fl_Button", _wrap_delete_Fl_Button, METH_VARARGS, (char *)"delete_Fl_Button(Fl_Button self)"},
	 { (char *)"disown_Fl_Button", _wrap_disown_Fl_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Button_swigregister", Fl_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FL_CHART_ENTRY", _wrap_new_FL_CHART_ENTRY, METH_VARARGS, (char *)"new_FL_CHART_ENTRY() -> FL_CHART_ENTRY"},
	 { (char *)"delete_FL_CHART_ENTRY", _wrap_delete_FL_CHART_ENTRY, METH_VARARGS, (char *)"delete_FL_CHART_ENTRY(FL_CHART_ENTRY self)"},
	 { (char *)"FL_CHART_ENTRY_swigregister", FL_CHART_ENTRY_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Chart_draw", _wrap_Fl_Chart_draw, METH_VARARGS, (char *)"Fl_Chart_draw(Fl_Chart self)"},
	 { (char *)"new_Fl_Chart", _wrap_new_Fl_Chart, METH_VARARGS, (char *)"new_Fl_Chart(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Chart"},
	 { (char *)"delete_Fl_Chart", _wrap_delete_Fl_Chart, METH_VARARGS, (char *)"delete_Fl_Chart(Fl_Chart self)"},
	 { (char *)"Fl_Chart_clear", _wrap_Fl_Chart_clear, METH_VARARGS, (char *)"Fl_Chart_clear(Fl_Chart self)"},
	 { (char *)"Fl_Chart_add", _wrap_Fl_Chart_add, METH_VARARGS, (char *)"Fl_Chart_add(Fl_Chart self, double val, char const * str=None, unsigned int col=0)"},
	 { (char *)"Fl_Chart_insert", _wrap_Fl_Chart_insert, METH_VARARGS, (char *)"Fl_Chart_insert(Fl_Chart self, int ind, double val, char const * str=None, unsigned int col=0)"},
	 { (char *)"Fl_Chart_replace", _wrap_Fl_Chart_replace, METH_VARARGS, (char *)"Fl_Chart_replace(Fl_Chart self, int ind, double val, char const * str=None, unsigned int col=0)"},
	 { (char *)"Fl_Chart_bounds", _wrap_Fl_Chart_bounds, METH_VARARGS, (char *)"\n"
		"bounds(double * a, double * b)\n"
		"Fl_Chart_bounds(Fl_Chart self, double a, double b)\n"
		""},
	 { (char *)"Fl_Chart_size", _wrap_Fl_Chart_size, METH_VARARGS, (char *)"\n"
		"size() -> int\n"
		"Fl_Chart_size(Fl_Chart self, int W, int H)\n"
		""},
	 { (char *)"Fl_Chart_maxsize", _wrap_Fl_Chart_maxsize, METH_VARARGS, (char *)"\n"
		"maxsize() -> int\n"
		"Fl_Chart_maxsize(Fl_Chart self, int m)\n"
		""},
	 { (char *)"Fl_Chart_textfont", _wrap_Fl_Chart_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Chart_textfont(Fl_Chart self, Fl_Font s)\n"
		""},
	 { (char *)"Fl_Chart_textsize", _wrap_Fl_Chart_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Chart_textsize(Fl_Chart self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Chart_textcolor", _wrap_Fl_Chart_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Chart_textcolor(Fl_Chart self, Fl_Color n)\n"
		""},
	 { (char *)"Fl_Chart_autosize", _wrap_Fl_Chart_autosize, METH_VARARGS, (char *)"\n"
		"autosize() -> uchar\n"
		"Fl_Chart_autosize(Fl_Chart self, uchar n)\n"
		""},
	 { (char *)"disown_Fl_Chart", _wrap_disown_Fl_Chart, METH_VARARGS, NULL},
	 { (char *)"Fl_Chart_swigregister", Fl_Chart_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Check_Browser", _wrap_new_Fl_Check_Browser, METH_VARARGS, (char *)"new_Fl_Check_Browser(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Check_Browser"},
	 { (char *)"delete_Fl_Check_Browser", _wrap_delete_Fl_Check_Browser, METH_VARARGS, (char *)"delete_Fl_Check_Browser(Fl_Check_Browser self)"},
	 { (char *)"Fl_Check_Browser_remove", _wrap_Fl_Check_Browser_remove, METH_VARARGS, (char *)"Fl_Check_Browser_remove(Fl_Check_Browser self, int item) -> int"},
	 { (char *)"Fl_Check_Browser_add", _wrap_Fl_Check_Browser_add, METH_VARARGS, (char *)"\n"
		"add(char const * s) -> int\n"
		"Fl_Check_Browser_add(Fl_Check_Browser self, char const * s, int b) -> int\n"
		""},
	 { (char *)"Fl_Check_Browser_clear", _wrap_Fl_Check_Browser_clear, METH_VARARGS, (char *)"Fl_Check_Browser_clear(Fl_Check_Browser self)"},
	 { (char *)"Fl_Check_Browser_nitems", _wrap_Fl_Check_Browser_nitems, METH_VARARGS, (char *)"Fl_Check_Browser_nitems(Fl_Check_Browser self) -> int"},
	 { (char *)"Fl_Check_Browser_nchecked", _wrap_Fl_Check_Browser_nchecked, METH_VARARGS, (char *)"Fl_Check_Browser_nchecked(Fl_Check_Browser self) -> int"},
	 { (char *)"Fl_Check_Browser_checked", _wrap_Fl_Check_Browser_checked, METH_VARARGS, (char *)"\n"
		"checked(int item) -> int\n"
		"Fl_Check_Browser_checked(Fl_Check_Browser self, int item, int b)\n"
		""},
	 { (char *)"Fl_Check_Browser_set_checked", _wrap_Fl_Check_Browser_set_checked, METH_VARARGS, (char *)"Fl_Check_Browser_set_checked(Fl_Check_Browser self, int item)"},
	 { (char *)"Fl_Check_Browser_check_all", _wrap_Fl_Check_Browser_check_all, METH_VARARGS, (char *)"Fl_Check_Browser_check_all(Fl_Check_Browser self)"},
	 { (char *)"Fl_Check_Browser_check_none", _wrap_Fl_Check_Browser_check_none, METH_VARARGS, (char *)"Fl_Check_Browser_check_none(Fl_Check_Browser self)"},
	 { (char *)"Fl_Check_Browser_value", _wrap_Fl_Check_Browser_value, METH_VARARGS, (char *)"Fl_Check_Browser_value(Fl_Check_Browser self) -> int"},
	 { (char *)"Fl_Check_Browser_text", _wrap_Fl_Check_Browser_text, METH_VARARGS, (char *)"Fl_Check_Browser_text(Fl_Check_Browser self, int item) -> char *"},
	 { (char *)"Fl_Check_Browser_handle", _wrap_Fl_Check_Browser_handle, METH_VARARGS, (char *)"Fl_Check_Browser_handle(Fl_Check_Browser self, int arg0) -> int"},
	 { (char *)"disown_Fl_Check_Browser", _wrap_disown_Fl_Check_Browser, METH_VARARGS, NULL},
	 { (char *)"Fl_Check_Browser_draw", _wrap_Fl_Check_Browser_draw, METH_VARARGS, (char *)"Fl_Check_Browser_draw(Fl_Check_Browser self)"},
	 { (char *)"Fl_Check_Browser_item_first", _wrap_Fl_Check_Browser_item_first, METH_VARARGS, (char *)"Fl_Check_Browser_item_first(Fl_Check_Browser self) -> void *"},
	 { (char *)"Fl_Check_Browser_item_next", _wrap_Fl_Check_Browser_item_next, METH_VARARGS, (char *)"Fl_Check_Browser_item_next(Fl_Check_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Check_Browser_item_prev", _wrap_Fl_Check_Browser_item_prev, METH_VARARGS, (char *)"Fl_Check_Browser_item_prev(Fl_Check_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Check_Browser_item_last", _wrap_Fl_Check_Browser_item_last, METH_VARARGS, (char *)"Fl_Check_Browser_item_last(Fl_Check_Browser self) -> void *"},
	 { (char *)"Fl_Check_Browser_item_height", _wrap_Fl_Check_Browser_item_height, METH_VARARGS, (char *)"Fl_Check_Browser_item_height(Fl_Check_Browser self, void * item) -> int"},
	 { (char *)"Fl_Check_Browser_item_width", _wrap_Fl_Check_Browser_item_width, METH_VARARGS, (char *)"Fl_Check_Browser_item_width(Fl_Check_Browser self, void * item) -> int"},
	 { (char *)"Fl_Check_Browser_item_quick_height", _wrap_Fl_Check_Browser_item_quick_height, METH_VARARGS, (char *)"Fl_Check_Browser_item_quick_height(Fl_Check_Browser self, void * item) -> int"},
	 { (char *)"Fl_Check_Browser_item_draw", _wrap_Fl_Check_Browser_item_draw, METH_VARARGS, (char *)"Fl_Check_Browser_item_draw(Fl_Check_Browser self, void * item, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Check_Browser_item_text", _wrap_Fl_Check_Browser_item_text, METH_VARARGS, (char *)"Fl_Check_Browser_item_text(Fl_Check_Browser self, void * item) -> char const *"},
	 { (char *)"Fl_Check_Browser_item_swap", _wrap_Fl_Check_Browser_item_swap, METH_VARARGS, (char *)"Fl_Check_Browser_item_swap(Fl_Check_Browser self, void * a, void * b)"},
	 { (char *)"Fl_Check_Browser_item_at", _wrap_Fl_Check_Browser_item_at, METH_VARARGS, (char *)"Fl_Check_Browser_item_at(Fl_Check_Browser self, int index) -> void *"},
	 { (char *)"Fl_Check_Browser_full_width", _wrap_Fl_Check_Browser_full_width, METH_VARARGS, (char *)"Fl_Check_Browser_full_width(Fl_Check_Browser self) -> int"},
	 { (char *)"Fl_Check_Browser_full_height", _wrap_Fl_Check_Browser_full_height, METH_VARARGS, (char *)"Fl_Check_Browser_full_height(Fl_Check_Browser self) -> int"},
	 { (char *)"Fl_Check_Browser_incr_height", _wrap_Fl_Check_Browser_incr_height, METH_VARARGS, (char *)"Fl_Check_Browser_incr_height(Fl_Check_Browser self) -> int"},
	 { (char *)"Fl_Check_Browser_item_select", _wrap_Fl_Check_Browser_item_select, METH_VARARGS, (char *)"Fl_Check_Browser_item_select(Fl_Check_Browser self, void * item, int val=1)"},
	 { (char *)"Fl_Check_Browser_item_selected", _wrap_Fl_Check_Browser_item_selected, METH_VARARGS, (char *)"Fl_Check_Browser_item_selected(Fl_Check_Browser self, void * item) -> int"},
	 { (char *)"Fl_Check_Browser_swigregister", Fl_Check_Browser_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Light_Button_draw", _wrap_Fl_Light_Button_draw, METH_VARARGS, (char *)"Fl_Light_Button_draw(Fl_Light_Button self)"},
	 { (char *)"Fl_Light_Button_handle", _wrap_Fl_Light_Button_handle, METH_VARARGS, (char *)"Fl_Light_Button_handle(Fl_Light_Button self, int arg0) -> int"},
	 { (char *)"new_Fl_Light_Button", _wrap_new_Fl_Light_Button, METH_VARARGS, (char *)"new_Fl_Light_Button(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Light_Button"},
	 { (char *)"delete_Fl_Light_Button", _wrap_delete_Fl_Light_Button, METH_VARARGS, (char *)"delete_Fl_Light_Button(Fl_Light_Button self)"},
	 { (char *)"disown_Fl_Light_Button", _wrap_disown_Fl_Light_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Light_Button_swigregister", Fl_Light_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Check_Button", _wrap_new_Fl_Check_Button, METH_VARARGS, (char *)"new_Fl_Check_Button(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Check_Button"},
	 { (char *)"delete_Fl_Check_Button", _wrap_delete_Fl_Check_Button, METH_VARARGS, (char *)"delete_Fl_Check_Button(Fl_Check_Button self)"},
	 { (char *)"disown_Fl_Check_Button", _wrap_disown_Fl_Check_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Check_Button_draw", _wrap_Fl_Check_Button_draw, METH_VARARGS, (char *)"Fl_Check_Button_draw(Fl_Check_Button self)"},
	 { (char *)"Fl_Check_Button_swigregister", Fl_Check_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Menu_", _wrap_new_Fl_Menu_, METH_VARARGS, (char *)"new_Fl_Menu_(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Menu_"},
	 { (char *)"delete_Fl_Menu_", _wrap_delete_Fl_Menu_, METH_VARARGS, (char *)"delete_Fl_Menu_(Fl_Menu_ self)"},
	 { (char *)"Fl_Menu__item_pathname", _wrap_Fl_Menu__item_pathname, METH_VARARGS, (char *)"Fl_Menu__item_pathname(Fl_Menu_ self, char * name, int namelen, Fl_Menu_Item finditem=None) -> int"},
	 { (char *)"Fl_Menu__picked", _wrap_Fl_Menu__picked, METH_VARARGS, (char *)"Fl_Menu__picked(Fl_Menu_ self, Fl_Menu_Item arg2) -> Fl_Menu_Item"},
	 { (char *)"Fl_Menu__find_item", _wrap_Fl_Menu__find_item, METH_VARARGS, (char *)"\n"
		"find_item(char const * name) -> Fl_Menu_Item\n"
		"Fl_Menu__find_item(Fl_Menu_ self, Fl_Callback * arg2) -> Fl_Menu_Item\n"
		""},
	 { (char *)"Fl_Menu__find_index", _wrap_Fl_Menu__find_index, METH_VARARGS, (char *)"\n"
		"find_index(char const * name) -> int\n"
		"find_index(Fl_Menu_Item item) -> int\n"
		"Fl_Menu__find_index(Fl_Menu_ self, Fl_Callback * cb) -> int\n"
		""},
	 { (char *)"Fl_Menu__test_shortcut", _wrap_Fl_Menu__test_shortcut, METH_VARARGS, (char *)"Fl_Menu__test_shortcut(Fl_Menu_ self) -> Fl_Menu_Item"},
	 { (char *)"Fl_Menu__insert", _wrap_Fl_Menu__insert, METH_VARARGS, (char *)"\n"
		"insert(int index, char const * arg3, int shortcut, Fl_Callback * arg5, void * arg6=None, \n"
		"    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, \n"
		"    int e=0) -> int\n"
		""},
	 { (char *)"Fl_Menu__size", _wrap_Fl_Menu__size, METH_VARARGS, (char *)"\n"
		"size() -> int\n"
		"Fl_Menu__size(Fl_Menu_ self, int W, int H)\n"
		""},
	 { (char *)"Fl_Menu__clear", _wrap_Fl_Menu__clear, METH_VARARGS, (char *)"Fl_Menu__clear(Fl_Menu_ self)"},
	 { (char *)"Fl_Menu__clear_submenu", _wrap_Fl_Menu__clear_submenu, METH_VARARGS, (char *)"Fl_Menu__clear_submenu(Fl_Menu_ self, int index) -> int"},
	 { (char *)"Fl_Menu__replace", _wrap_Fl_Menu__replace, METH_VARARGS, (char *)"Fl_Menu__replace(Fl_Menu_ self, int arg2, char const * arg3)"},
	 { (char *)"Fl_Menu__remove", _wrap_Fl_Menu__remove, METH_VARARGS, (char *)"Fl_Menu__remove(Fl_Menu_ self, int arg2)"},
	 { (char *)"Fl_Menu__shortcut", _wrap_Fl_Menu__shortcut, METH_VARARGS, (char *)"Fl_Menu__shortcut(Fl_Menu_ self, int i, int s)"},
	 { (char *)"Fl_Menu__mode", _wrap_Fl_Menu__mode, METH_VARARGS, (char *)"\n"
		"mode(int i, int fl)\n"
		"Fl_Menu__mode(Fl_Menu_ self, int i) -> int\n"
		""},
	 { (char *)"Fl_Menu__mvalue", _wrap_Fl_Menu__mvalue, METH_VARARGS, (char *)"Fl_Menu__mvalue(Fl_Menu_ self) -> Fl_Menu_Item"},
	 { (char *)"Fl_Menu__value", _wrap_Fl_Menu__value, METH_VARARGS, (char *)"\n"
		"value() -> int\n"
		"Fl_Menu__value(Fl_Menu_ self, int i) -> int\n"
		""},
	 { (char *)"Fl_Menu__text", _wrap_Fl_Menu__text, METH_VARARGS, (char *)"\n"
		"text() -> char const\n"
		"Fl_Menu__text(Fl_Menu_ self, int i) -> char const *\n"
		""},
	 { (char *)"Fl_Menu__textfont", _wrap_Fl_Menu__textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Menu__textfont(Fl_Menu_ self, Fl_Font c)\n"
		""},
	 { (char *)"Fl_Menu__textsize", _wrap_Fl_Menu__textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Menu__textsize(Fl_Menu_ self, Fl_Fontsize c)\n"
		""},
	 { (char *)"Fl_Menu__textcolor", _wrap_Fl_Menu__textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Menu__textcolor(Fl_Menu_ self, Fl_Color c)\n"
		""},
	 { (char *)"Fl_Menu__down_box", _wrap_Fl_Menu__down_box, METH_VARARGS, (char *)"\n"
		"down_box() -> Fl_Boxtype\n"
		"Fl_Menu__down_box(Fl_Menu_ self, Fl_Boxtype b)\n"
		""},
	 { (char *)"Fl_Menu__down_color", _wrap_Fl_Menu__down_color, METH_VARARGS, (char *)"\n"
		"down_color() -> Fl_Color\n"
		"Fl_Menu__down_color(Fl_Menu_ self, unsigned int c)\n"
		""},
	 { (char *)"Fl_Menu__setonly", _wrap_Fl_Menu__setonly, METH_VARARGS, (char *)"Fl_Menu__setonly(Fl_Menu_ self, Fl_Menu_Item item)"},
	 { (char *)"Fl_Menu__copy", _wrap_Fl_Menu__copy, METH_VARARGS, (char *)"\n"
		"copy(Fl_Menu_Item m, void * user_data=None)\n"
		"Fl_Menu__copy(Fl_Menu_ self, PyObject * args, PyObject * user_data=None)\n"
		""},
	 { (char *)"Fl_Menu__add", _wrap_Fl_Menu__add, METH_VARARGS, (char *)"\n"
		"add(char const * arg2, int shortcut, Fl_Callback * arg4, void * arg5=None, int arg6=0) -> int\n"
		"add(char const * arg2) -> int\n"
		"Fl_Menu__add(Fl_Menu_ self, PyObject * lObj, PyObject * sObj, PyObject * cObj, PyObject * uObj=None, \n"
		"    PyObject * fObj=None) -> int\n"
		""},
	 { (char *)"Fl_Menu__menu", _wrap_Fl_Menu__menu, METH_VARARGS, (char *)"\n"
		"menu() -> Fl_Menu_Item\n"
		"menu(PyObject * args)\n"
		"Fl_Menu__menu(Fl_Menu_ self) -> PyObject *\n"
		""},
	 { (char *)"disown_Fl_Menu_", _wrap_disown_Fl_Menu_, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu__swigregister", Fl_Menu__swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Choice_draw", _wrap_Fl_Choice_draw, METH_VARARGS, (char *)"Fl_Choice_draw(Fl_Choice self)"},
	 { (char *)"Fl_Choice_handle", _wrap_Fl_Choice_handle, METH_VARARGS, (char *)"Fl_Choice_handle(Fl_Choice self, int arg0) -> int"},
	 { (char *)"new_Fl_Choice", _wrap_new_Fl_Choice, METH_VARARGS, (char *)"new_Fl_Choice(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Choice"},
	 { (char *)"Fl_Choice_value", _wrap_Fl_Choice_value, METH_VARARGS, (char *)"\n"
		"value() -> int\n"
		"Fl_Choice_value(Fl_Choice self, int v) -> int\n"
		""},
	 { (char *)"delete_Fl_Choice", _wrap_delete_Fl_Choice, METH_VARARGS, (char *)"delete_Fl_Choice(Fl_Choice self)"},
	 { (char *)"disown_Fl_Choice", _wrap_disown_Fl_Choice, METH_VARARGS, NULL},
	 { (char *)"Fl_Choice_swigregister", Fl_Choice_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Clock_Output_draw", _wrap_Fl_Clock_Output_draw, METH_VARARGS, (char *)"Fl_Clock_Output_draw(Fl_Clock_Output self)"},
	 { (char *)"new_Fl_Clock_Output", _wrap_new_Fl_Clock_Output, METH_VARARGS, (char *)"new_Fl_Clock_Output(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Clock_Output"},
	 { (char *)"Fl_Clock_Output_value", _wrap_Fl_Clock_Output_value, METH_VARARGS, (char *)"\n"
		"value(ulong v)\n"
		"value(int H, int m, int s)\n"
		"Fl_Clock_Output_value(Fl_Clock_Output self) -> ulong\n"
		""},
	 { (char *)"Fl_Clock_Output_hour", _wrap_Fl_Clock_Output_hour, METH_VARARGS, (char *)"Fl_Clock_Output_hour(Fl_Clock_Output self) -> int"},
	 { (char *)"Fl_Clock_Output_minute", _wrap_Fl_Clock_Output_minute, METH_VARARGS, (char *)"Fl_Clock_Output_minute(Fl_Clock_Output self) -> int"},
	 { (char *)"Fl_Clock_Output_second", _wrap_Fl_Clock_Output_second, METH_VARARGS, (char *)"Fl_Clock_Output_second(Fl_Clock_Output self) -> int"},
	 { (char *)"delete_Fl_Clock_Output", _wrap_delete_Fl_Clock_Output, METH_VARARGS, (char *)"delete_Fl_Clock_Output(Fl_Clock_Output self)"},
	 { (char *)"disown_Fl_Clock_Output", _wrap_disown_Fl_Clock_Output, METH_VARARGS, NULL},
	 { (char *)"Fl_Clock_Output_swigregister", Fl_Clock_Output_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Clock_handle", _wrap_Fl_Clock_handle, METH_VARARGS, (char *)"Fl_Clock_handle(Fl_Clock self, int arg0) -> int"},
	 { (char *)"new_Fl_Clock", _wrap_new_Fl_Clock, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"delete_Fl_Clock", _wrap_delete_Fl_Clock, METH_VARARGS, (char *)"delete_Fl_Clock(Fl_Clock self)"},
	 { (char *)"disown_Fl_Clock", _wrap_disown_Fl_Clock, METH_VARARGS, NULL},
	 { (char *)"Fl_Clock_draw", _wrap_Fl_Clock_draw, METH_VARARGS, (char *)"Fl_Clock_draw(Fl_Clock self)"},
	 { (char *)"Fl_Clock_swigregister", Fl_Clock_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Value_Input_handle", _wrap_Fl_Value_Input_handle, METH_VARARGS, (char *)"Fl_Value_Input_handle(Fl_Value_Input self, int arg0) -> int"},
	 { (char *)"Fl_Value_Input_draw", _wrap_Fl_Value_Input_draw, METH_VARARGS, (char *)"Fl_Value_Input_draw(Fl_Value_Input self)"},
	 { (char *)"Fl_Value_Input_resize", _wrap_Fl_Value_Input_resize, METH_VARARGS, (char *)"Fl_Value_Input_resize(Fl_Value_Input self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"new_Fl_Value_Input", _wrap_new_Fl_Value_Input, METH_VARARGS, (char *)"new_Fl_Value_Input(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Input"},
	 { (char *)"delete_Fl_Value_Input", _wrap_delete_Fl_Value_Input, METH_VARARGS, (char *)"delete_Fl_Value_Input(Fl_Value_Input self)"},
	 { (char *)"Fl_Value_Input_soft", _wrap_Fl_Value_Input_soft, METH_VARARGS, (char *)"\n"
		"soft(char s)\n"
		"Fl_Value_Input_soft(Fl_Value_Input self) -> char\n"
		""},
	 { (char *)"Fl_Value_Input_shortcut", _wrap_Fl_Value_Input_shortcut, METH_VARARGS, (char *)"\n"
		"shortcut() -> int\n"
		"Fl_Value_Input_shortcut(Fl_Value_Input self, int s)\n"
		""},
	 { (char *)"Fl_Value_Input_textfont", _wrap_Fl_Value_Input_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Value_Input_textfont(Fl_Value_Input self, Fl_Font s)\n"
		""},
	 { (char *)"Fl_Value_Input_textsize", _wrap_Fl_Value_Input_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Value_Input_textsize(Fl_Value_Input self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Value_Input_textcolor", _wrap_Fl_Value_Input_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Value_Input_textcolor(Fl_Value_Input self, Fl_Color n)\n"
		""},
	 { (char *)"Fl_Value_Input_cursor_color", _wrap_Fl_Value_Input_cursor_color, METH_VARARGS, (char *)"\n"
		"cursor_color() -> Fl_Color\n"
		"Fl_Value_Input_cursor_color(Fl_Value_Input self, Fl_Color n)\n"
		""},
	 { (char *)"disown_Fl_Value_Input", _wrap_disown_Fl_Value_Input, METH_VARARGS, NULL},
	 { (char *)"Fl_Value_Input_swigregister", Fl_Value_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"Flcc_HueBox_draw", _wrap_Flcc_HueBox_draw, METH_VARARGS, (char *)"Flcc_HueBox_draw(Flcc_HueBox self)"},
	 { (char *)"Flcc_HueBox_handle", _wrap_Flcc_HueBox_handle, METH_VARARGS, (char *)"Flcc_HueBox_handle(Flcc_HueBox self, int arg0) -> int"},
	 { (char *)"new_Flcc_HueBox", _wrap_new_Flcc_HueBox, METH_VARARGS, (char *)"new_Flcc_HueBox(PyObject * self, int X, int Y, int W, int H) -> Flcc_HueBox"},
	 { (char *)"delete_Flcc_HueBox", _wrap_delete_Flcc_HueBox, METH_VARARGS, (char *)"delete_Flcc_HueBox(Flcc_HueBox self)"},
	 { (char *)"disown_Flcc_HueBox", _wrap_disown_Flcc_HueBox, METH_VARARGS, NULL},
	 { (char *)"Flcc_HueBox_swigregister", Flcc_HueBox_swigregister, METH_VARARGS, NULL},
	 { (char *)"Flcc_ValueBox_draw", _wrap_Flcc_ValueBox_draw, METH_VARARGS, (char *)"Flcc_ValueBox_draw(Flcc_ValueBox self)"},
	 { (char *)"Flcc_ValueBox_handle", _wrap_Flcc_ValueBox_handle, METH_VARARGS, (char *)"Flcc_ValueBox_handle(Flcc_ValueBox self, int arg0) -> int"},
	 { (char *)"new_Flcc_ValueBox", _wrap_new_Flcc_ValueBox, METH_VARARGS, (char *)"new_Flcc_ValueBox(PyObject * self, int X, int Y, int W, int H) -> Flcc_ValueBox"},
	 { (char *)"delete_Flcc_ValueBox", _wrap_delete_Flcc_ValueBox, METH_VARARGS, (char *)"delete_Flcc_ValueBox(Flcc_ValueBox self)"},
	 { (char *)"disown_Flcc_ValueBox", _wrap_disown_Flcc_ValueBox, METH_VARARGS, NULL},
	 { (char *)"Flcc_ValueBox_swigregister", Flcc_ValueBox_swigregister, METH_VARARGS, NULL},
	 { (char *)"Flcc_Value_Input_format", _wrap_Flcc_Value_Input_format, METH_VARARGS, (char *)"Flcc_Value_Input_format(Flcc_Value_Input self, char * arg0) -> int"},
	 { (char *)"new_Flcc_Value_Input", _wrap_new_Flcc_Value_Input, METH_VARARGS, (char *)"new_Flcc_Value_Input(PyObject * self, int X, int Y, int W, int H) -> Flcc_Value_Input"},
	 { (char *)"delete_Flcc_Value_Input", _wrap_delete_Flcc_Value_Input, METH_VARARGS, (char *)"delete_Flcc_Value_Input(Flcc_Value_Input self)"},
	 { (char *)"disown_Flcc_Value_Input", _wrap_disown_Flcc_Value_Input, METH_VARARGS, NULL},
	 { (char *)"Flcc_Value_Input_draw", _wrap_Flcc_Value_Input_draw, METH_VARARGS, (char *)"Flcc_Value_Input_draw(Flcc_Value_Input self)"},
	 { (char *)"Flcc_Value_Input_swigregister", Flcc_Value_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Color_Chooser_mode", _wrap_Fl_Color_Chooser_mode, METH_VARARGS, (char *)"\n"
		"mode() -> int\n"
		"Fl_Color_Chooser_mode(Fl_Color_Chooser self, int newMode)\n"
		""},
	 { (char *)"Fl_Color_Chooser_hue", _wrap_Fl_Color_Chooser_hue, METH_VARARGS, (char *)"Fl_Color_Chooser_hue(Fl_Color_Chooser self) -> double"},
	 { (char *)"Fl_Color_Chooser_saturation", _wrap_Fl_Color_Chooser_saturation, METH_VARARGS, (char *)"Fl_Color_Chooser_saturation(Fl_Color_Chooser self) -> double"},
	 { (char *)"Fl_Color_Chooser_value", _wrap_Fl_Color_Chooser_value, METH_VARARGS, (char *)"Fl_Color_Chooser_value(Fl_Color_Chooser self) -> double"},
	 { (char *)"Fl_Color_Chooser_r", _wrap_Fl_Color_Chooser_r, METH_VARARGS, (char *)"Fl_Color_Chooser_r(Fl_Color_Chooser self) -> double"},
	 { (char *)"Fl_Color_Chooser_g", _wrap_Fl_Color_Chooser_g, METH_VARARGS, (char *)"Fl_Color_Chooser_g(Fl_Color_Chooser self) -> double"},
	 { (char *)"Fl_Color_Chooser_b", _wrap_Fl_Color_Chooser_b, METH_VARARGS, (char *)"Fl_Color_Chooser_b(Fl_Color_Chooser self) -> double"},
	 { (char *)"Fl_Color_Chooser_hsv", _wrap_Fl_Color_Chooser_hsv, METH_VARARGS, (char *)"Fl_Color_Chooser_hsv(Fl_Color_Chooser self, double H, double S, double V) -> int"},
	 { (char *)"Fl_Color_Chooser_rgb", _wrap_Fl_Color_Chooser_rgb, METH_VARARGS, (char *)"Fl_Color_Chooser_rgb(Fl_Color_Chooser self, double R, double G, double B) -> int"},
	 { (char *)"Fl_Color_Chooser_hsv2rgb", _wrap_Fl_Color_Chooser_hsv2rgb, METH_VARARGS, (char *)"Fl_Color_Chooser_hsv2rgb(double H, double S, double V, double & R, double & G, double & B)"},
	 { (char *)"Fl_Color_Chooser_rgb2hsv", _wrap_Fl_Color_Chooser_rgb2hsv, METH_VARARGS, (char *)"Fl_Color_Chooser_rgb2hsv(double R, double G, double B, double & H, double & S, double & V)"},
	 { (char *)"new_Fl_Color_Chooser", _wrap_new_Fl_Color_Chooser, METH_VARARGS, (char *)"new_Fl_Color_Chooser(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Color_Chooser"},
	 { (char *)"delete_Fl_Color_Chooser", _wrap_delete_Fl_Color_Chooser, METH_VARARGS, (char *)"delete_Fl_Color_Chooser(Fl_Color_Chooser self)"},
	 { (char *)"disown_Fl_Color_Chooser", _wrap_disown_Fl_Color_Chooser, METH_VARARGS, NULL},
	 { (char *)"Fl_Color_Chooser_draw", _wrap_Fl_Color_Chooser_draw, METH_VARARGS, (char *)"Fl_Color_Chooser_draw(Fl_Color_Chooser self)"},
	 { (char *)"Fl_Color_Chooser_swigregister", Fl_Color_Chooser_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_color_chooser", _wrap_fl_color_chooser, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Counter_draw", _wrap_Fl_Counter_draw, METH_VARARGS, (char *)"Fl_Counter_draw(Fl_Counter self)"},
	 { (char *)"Fl_Counter_handle", _wrap_Fl_Counter_handle, METH_VARARGS, (char *)"Fl_Counter_handle(Fl_Counter self, int arg0) -> int"},
	 { (char *)"new_Fl_Counter", _wrap_new_Fl_Counter, METH_VARARGS, (char *)"new_Fl_Counter(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Counter"},
	 { (char *)"delete_Fl_Counter", _wrap_delete_Fl_Counter, METH_VARARGS, (char *)"delete_Fl_Counter(Fl_Counter self)"},
	 { (char *)"Fl_Counter_lstep", _wrap_Fl_Counter_lstep, METH_VARARGS, (char *)"Fl_Counter_lstep(Fl_Counter self, double a)"},
	 { (char *)"Fl_Counter_step", _wrap_Fl_Counter_step, METH_VARARGS, (char *)"\n"
		"step(double a, double b)\n"
		"step(double a)\n"
		"Fl_Counter_step(Fl_Counter self) -> double\n"
		""},
	 { (char *)"Fl_Counter_textfont", _wrap_Fl_Counter_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Counter_textfont(Fl_Counter self, Fl_Font s)\n"
		""},
	 { (char *)"Fl_Counter_textsize", _wrap_Fl_Counter_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Counter_textsize(Fl_Counter self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Counter_textcolor", _wrap_Fl_Counter_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Counter_textcolor(Fl_Counter self, Fl_Color s)\n"
		""},
	 { (char *)"disown_Fl_Counter", _wrap_disown_Fl_Counter, METH_VARARGS, NULL},
	 { (char *)"Fl_Counter_swigregister", Fl_Counter_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Dial_draw", _wrap_Fl_Dial_draw, METH_VARARGS, (char *)"Fl_Dial_draw(Fl_Dial self)"},
	 { (char *)"Fl_Dial_handle", _wrap_Fl_Dial_handle, METH_VARARGS, (char *)"Fl_Dial_handle(Fl_Dial self, int arg0) -> int"},
	 { (char *)"new_Fl_Dial", _wrap_new_Fl_Dial, METH_VARARGS, (char *)"new_Fl_Dial(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Dial"},
	 { (char *)"Fl_Dial_angle1", _wrap_Fl_Dial_angle1, METH_VARARGS, (char *)"\n"
		"angle1() -> short\n"
		"Fl_Dial_angle1(Fl_Dial self, short a)\n"
		""},
	 { (char *)"Fl_Dial_angle2", _wrap_Fl_Dial_angle2, METH_VARARGS, (char *)"\n"
		"angle2() -> short\n"
		"Fl_Dial_angle2(Fl_Dial self, short a)\n"
		""},
	 { (char *)"Fl_Dial_angles", _wrap_Fl_Dial_angles, METH_VARARGS, (char *)"Fl_Dial_angles(Fl_Dial self, short a, short b)"},
	 { (char *)"delete_Fl_Dial", _wrap_delete_Fl_Dial, METH_VARARGS, (char *)"delete_Fl_Dial(Fl_Dial self)"},
	 { (char *)"disown_Fl_Dial", _wrap_disown_Fl_Dial, METH_VARARGS, NULL},
	 { (char *)"Fl_Dial_swigregister", Fl_Dial_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Window_shape", _wrap_Fl_Window_shape, METH_VARARGS, (char *)"\n"
		"shape(Fl_Image img)\n"
		"Fl_Window_shape(Fl_Window self, Fl_Image b)\n"
		""},
	 { (char *)"Fl_Window_draw", _wrap_Fl_Window_draw, METH_VARARGS, (char *)"Fl_Window_draw(Fl_Window self)"},
	 { (char *)"Fl_Window_flush", _wrap_Fl_Window_flush, METH_VARARGS, (char *)"Fl_Window_flush(Fl_Window self)"},
	 { (char *)"new_Fl_Window", _wrap_new_Fl_Window, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"delete_Fl_Window", _wrap_delete_Fl_Window, METH_VARARGS, (char *)"delete_Fl_Window(Fl_Window self)"},
	 { (char *)"Fl_Window_handle", _wrap_Fl_Window_handle, METH_VARARGS, (char *)"Fl_Window_handle(Fl_Window self, int arg0) -> int"},
	 { (char *)"Fl_Window_resize", _wrap_Fl_Window_resize, METH_VARARGS, (char *)"Fl_Window_resize(Fl_Window self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Window_clear_border", _wrap_Fl_Window_clear_border, METH_VARARGS, (char *)"Fl_Window_clear_border(Fl_Window self)"},
	 { (char *)"Fl_Window_border", _wrap_Fl_Window_border, METH_VARARGS, (char *)"\n"
		"border(int b)\n"
		"Fl_Window_border(Fl_Window self) -> unsigned int\n"
		""},
	 { (char *)"Fl_Window_set_override", _wrap_Fl_Window_set_override, METH_VARARGS, (char *)"Fl_Window_set_override(Fl_Window self)"},
	 { (char *)"Fl_Window_override", _wrap_Fl_Window_override, METH_VARARGS, (char *)"Fl_Window_override(Fl_Window self) -> unsigned int"},
	 { (char *)"Fl_Window_set_modal", _wrap_Fl_Window_set_modal, METH_VARARGS, (char *)"Fl_Window_set_modal(Fl_Window self)"},
	 { (char *)"Fl_Window_modal", _wrap_Fl_Window_modal, METH_VARARGS, (char *)"Fl_Window_modal(Fl_Window self) -> unsigned int"},
	 { (char *)"Fl_Window_set_non_modal", _wrap_Fl_Window_set_non_modal, METH_VARARGS, (char *)"Fl_Window_set_non_modal(Fl_Window self)"},
	 { (char *)"Fl_Window_non_modal", _wrap_Fl_Window_non_modal, METH_VARARGS, (char *)"Fl_Window_non_modal(Fl_Window self) -> unsigned int"},
	 { (char *)"Fl_Window_clear_modal_states", _wrap_Fl_Window_clear_modal_states, METH_VARARGS, (char *)"Fl_Window_clear_modal_states(Fl_Window self)"},
	 { (char *)"Fl_Window_set_menu_window", _wrap_Fl_Window_set_menu_window, METH_VARARGS, (char *)"Fl_Window_set_menu_window(Fl_Window self)"},
	 { (char *)"Fl_Window_menu_window", _wrap_Fl_Window_menu_window, METH_VARARGS, (char *)"Fl_Window_menu_window(Fl_Window self) -> unsigned int"},
	 { (char *)"Fl_Window_set_tooltip_window", _wrap_Fl_Window_set_tooltip_window, METH_VARARGS, (char *)"Fl_Window_set_tooltip_window(Fl_Window self)"},
	 { (char *)"Fl_Window_tooltip_window", _wrap_Fl_Window_tooltip_window, METH_VARARGS, (char *)"Fl_Window_tooltip_window(Fl_Window self) -> unsigned int"},
	 { (char *)"Fl_Window_hotspot", _wrap_Fl_Window_hotspot, METH_VARARGS, (char *)"\n"
		"hotspot(int x, int y, int offscreen=0)\n"
		"Fl_Window_hotspot(Fl_Window self, Fl_Widget arg2, int offscreen=0)\n"
		""},
	 { (char *)"Fl_Window_free_position", _wrap_Fl_Window_free_position, METH_VARARGS, (char *)"Fl_Window_free_position(Fl_Window self)"},
	 { (char *)"Fl_Window_size_range", _wrap_Fl_Window_size_range, METH_VARARGS, (char *)"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)"},
	 { (char *)"Fl_Window_iconlabel", _wrap_Fl_Window_iconlabel, METH_VARARGS, (char *)"\n"
		"iconlabel() -> char const\n"
		"Fl_Window_iconlabel(Fl_Window self, char const * arg2)\n"
		""},
	 { (char *)"Fl_Window_label", _wrap_Fl_Window_label, METH_VARARGS, (char *)"\n"
		"label() -> char const\n"
		"label(char const * arg2)\n"
		"Fl_Window_label(Fl_Window self, char const * label, char const * iconlabel)\n"
		""},
	 { (char *)"Fl_Window_copy_label", _wrap_Fl_Window_copy_label, METH_VARARGS, (char *)"Fl_Window_copy_label(Fl_Window self, char const * a)"},
	 { (char *)"Fl_Window_default_xclass", _wrap_Fl_Window_default_xclass, METH_VARARGS, (char *)"\n"
		"default_xclass(char const * arg1)\n"
		"Fl_Window_default_xclass() -> char const *\n"
		""},
	 { (char *)"Fl_Window_xclass", _wrap_Fl_Window_xclass, METH_VARARGS, (char *)"\n"
		"xclass() -> char const\n"
		"Fl_Window_xclass(Fl_Window self, char const * c)\n"
		""},
	 { (char *)"Fl_Window_default_icon", _wrap_Fl_Window_default_icon, METH_VARARGS, (char *)"Fl_Window_default_icon(Fl_RGB_Image arg1)"},
	 { (char *)"Fl_Window_default_icons", _wrap_Fl_Window_default_icons, METH_VARARGS, (char *)"Fl_Window_default_icons(Fl_RGB_Image const *[] arg1, int arg2)"},
	 { (char *)"Fl_Window_icons", _wrap_Fl_Window_icons, METH_VARARGS, (char *)"Fl_Window_icons(Fl_Window self, Fl_RGB_Image const *[] arg2, int arg3)"},
	 { (char *)"Fl_Window_icon", _wrap_Fl_Window_icon, METH_VARARGS, (char *)"\n"
		"icon(Fl_RGB_Image arg2)\n"
		"icon() -> void const\n"
		"Fl_Window_icon(Fl_Window self, void const * ic)\n"
		""},
	 { (char *)"Fl_Window_shown", _wrap_Fl_Window_shown, METH_VARARGS, (char *)"Fl_Window_shown(Fl_Window self) -> int"},
	 { (char *)"Fl_Window_hide", _wrap_Fl_Window_hide, METH_VARARGS, (char *)"Fl_Window_hide(Fl_Window self)"},
	 { (char *)"Fl_Window_wait_for_expose", _wrap_Fl_Window_wait_for_expose, METH_VARARGS, (char *)"Fl_Window_wait_for_expose(Fl_Window self)"},
	 { (char *)"Fl_Window_fullscreen", _wrap_Fl_Window_fullscreen, METH_VARARGS, (char *)"Fl_Window_fullscreen(Fl_Window self)"},
	 { (char *)"Fl_Window_fullscreen_off", _wrap_Fl_Window_fullscreen_off, METH_VARARGS, (char *)"\n"
		"fullscreen_off()\n"
		"Fl_Window_fullscreen_off(Fl_Window self, int X, int Y, int W, int H)\n"
		""},
	 { (char *)"Fl_Window_fullscreen_active", _wrap_Fl_Window_fullscreen_active, METH_VARARGS, (char *)"Fl_Window_fullscreen_active(Fl_Window self) -> unsigned int"},
	 { (char *)"Fl_Window_fullscreen_screens", _wrap_Fl_Window_fullscreen_screens, METH_VARARGS, (char *)"Fl_Window_fullscreen_screens(Fl_Window self, int top, int bottom, int left, int right)"},
	 { (char *)"Fl_Window_iconize", _wrap_Fl_Window_iconize, METH_VARARGS, (char *)"Fl_Window_iconize(Fl_Window self)"},
	 { (char *)"Fl_Window_x_root", _wrap_Fl_Window_x_root, METH_VARARGS, (char *)"Fl_Window_x_root(Fl_Window self) -> int"},
	 { (char *)"Fl_Window_y_root", _wrap_Fl_Window_y_root, METH_VARARGS, (char *)"Fl_Window_y_root(Fl_Window self) -> int"},
	 { (char *)"Fl_Window_current", _wrap_Fl_Window_current, METH_VARARGS, (char *)"Fl_Window_current() -> Fl_Window"},
	 { (char *)"Fl_Window_make_current", _wrap_Fl_Window_make_current, METH_VARARGS, (char *)"Fl_Window_make_current(Fl_Window self)"},
	 { (char *)"Fl_Window_as_window", _wrap_Fl_Window_as_window, METH_VARARGS, (char *)"Fl_Window_as_window(Fl_Window self) -> Fl_Window"},
	 { (char *)"Fl_Window_cursor", _wrap_Fl_Window_cursor, METH_VARARGS, (char *)"\n"
		"cursor(Fl_Cursor arg2)\n"
		"cursor(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"
		""},
	 { (char *)"Fl_Window_default_cursor", _wrap_Fl_Window_default_cursor, METH_VARARGS, (char *)"\n"
		"default_cursor(Fl_Cursor arg2)\n"
		"Fl_Window_default_cursor(Fl_Window self, Fl_Cursor c, Fl_Color arg3, Fl_Color arg4=)\n"
		""},
	 { (char *)"Fl_Window_default_callback", _wrap_Fl_Window_default_callback, METH_VARARGS, (char *)"Fl_Window_default_callback(Fl_Window arg1, void * v)"},
	 { (char *)"Fl_Window_decorated_w", _wrap_Fl_Window_decorated_w, METH_VARARGS, (char *)"Fl_Window_decorated_w(Fl_Window self) -> int"},
	 { (char *)"Fl_Window_decorated_h", _wrap_Fl_Window_decorated_h, METH_VARARGS, (char *)"Fl_Window_decorated_h(Fl_Window self) -> int"},
	 { (char *)"Fl_Window_show", _wrap_Fl_Window_show, METH_VARARGS, (char *)"Fl_Window_show(Fl_Window self, PyObject * count=None, PyObject * data=None)"},
	 { (char *)"disown_Fl_Window", _wrap_disown_Fl_Window, METH_VARARGS, NULL},
	 { (char *)"Fl_Window_swigregister", Fl_Window_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Double_Window_flush", _wrap_Fl_Double_Window_flush, METH_VARARGS, (char *)"Fl_Double_Window_flush(Fl_Double_Window self)"},
	 { (char *)"Fl_Double_Window_resize", _wrap_Fl_Double_Window_resize, METH_VARARGS, (char *)"Fl_Double_Window_resize(Fl_Double_Window self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"Fl_Double_Window_hide", _wrap_Fl_Double_Window_hide, METH_VARARGS, (char *)"Fl_Double_Window_hide(Fl_Double_Window self)"},
	 { (char *)"delete_Fl_Double_Window", _wrap_delete_Fl_Double_Window, METH_VARARGS, (char *)"delete_Fl_Double_Window(Fl_Double_Window self)"},
	 { (char *)"new_Fl_Double_Window", _wrap_new_Fl_Double_Window, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Double_Window_show", _wrap_Fl_Double_Window_show, METH_VARARGS, (char *)"Fl_Double_Window_show(Fl_Double_Window self, PyObject * count=None, PyObject * data=None)"},
	 { (char *)"disown_Fl_Double_Window", _wrap_disown_Fl_Double_Window, METH_VARARGS, NULL},
	 { (char *)"Fl_Double_Window_draw", _wrap_Fl_Double_Window_draw, METH_VARARGS, (char *)"Fl_Double_Window_draw(Fl_Double_Window self)"},
	 { (char *)"Fl_Double_Window_swigregister", Fl_Double_Window_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_color", _wrap_fl_color, METH_VARARGS, (char *)"\n"
		"fl_color(Fl_Color c)\n"
		"fl_color(uchar r, uchar g, uchar b)\n"
		"fl_color() -> Fl_Color\n"
		""},
	 { (char *)"fl_push_clip", _wrap_fl_push_clip, METH_VARARGS, (char *)"fl_push_clip(int x, int y, int w, int h)"},
	 { (char *)"fl_push_no_clip", _wrap_fl_push_no_clip, METH_VARARGS, (char *)"fl_push_no_clip()"},
	 { (char *)"fl_pop_clip", _wrap_fl_pop_clip, METH_VARARGS, (char *)"fl_pop_clip()"},
	 { (char *)"fl_not_clipped", _wrap_fl_not_clipped, METH_VARARGS, (char *)"fl_not_clipped(int x, int y, int w, int h) -> int"},
	 { (char *)"fl_clip_box", _wrap_fl_clip_box, METH_VARARGS, (char *)"fl_clip_box(int x, int y, int w, int h) -> int"},
	 { (char *)"fl_restore_clip", _wrap_fl_restore_clip, METH_VARARGS, (char *)"fl_restore_clip()"},
	 { (char *)"fl_clip_region", _wrap_fl_clip_region, METH_VARARGS, (char *)"\n"
		"fl_clip_region(Fl_Region r)\n"
		"fl_clip_region() -> Fl_Region\n"
		""},
	 { (char *)"fl_point", _wrap_fl_point, METH_VARARGS, (char *)"fl_point(int x, int y)"},
	 { (char *)"fl_line_style", _wrap_fl_line_style, METH_VARARGS, (char *)"fl_line_style(int style, int width=0, char * dashes=None)"},
	 { (char *)"fl_rect", _wrap_fl_rect, METH_VARARGS, (char *)"\n"
		"fl_rect(int x, int y, int w, int h)\n"
		"fl_rect(int x, int y, int w, int h, Fl_Color c)\n"
		""},
	 { (char *)"fl_rectf", _wrap_fl_rectf, METH_VARARGS, (char *)"\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(int x, int y, int w, int h, uchar r, uchar g, uchar b)\n"
		""},
	 { (char *)"fl_line", _wrap_fl_line, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"fl_loop", _wrap_fl_loop, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"fl_polygon", _wrap_fl_polygon, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"fl_xyline", _wrap_fl_xyline, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"fl_yxline", _wrap_fl_yxline, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"fl_pie", _wrap_fl_pie, METH_VARARGS, (char *)"fl_pie(int x, int y, int w, int h, double a1, double a2)"},
	 { (char *)"fl_push_matrix", _wrap_fl_push_matrix, METH_VARARGS, (char *)"fl_push_matrix()"},
	 { (char *)"fl_pop_matrix", _wrap_fl_pop_matrix, METH_VARARGS, (char *)"fl_pop_matrix()"},
	 { (char *)"fl_scale", _wrap_fl_scale, METH_VARARGS, (char *)"\n"
		"fl_scale(double x, double y)\n"
		"fl_scale(double x)\n"
		""},
	 { (char *)"fl_translate", _wrap_fl_translate, METH_VARARGS, (char *)"fl_translate(double x, double y)"},
	 { (char *)"fl_rotate", _wrap_fl_rotate, METH_VARARGS, (char *)"fl_rotate(double d)"},
	 { (char *)"fl_mult_matrix", _wrap_fl_mult_matrix, METH_VARARGS, (char *)"fl_mult_matrix(double a, double b, double c, double d, double x, double y)"},
	 { (char *)"fl_begin_points", _wrap_fl_begin_points, METH_VARARGS, (char *)"fl_begin_points()"},
	 { (char *)"fl_begin_line", _wrap_fl_begin_line, METH_VARARGS, (char *)"fl_begin_line()"},
	 { (char *)"fl_begin_loop", _wrap_fl_begin_loop, METH_VARARGS, (char *)"fl_begin_loop()"},
	 { (char *)"fl_begin_polygon", _wrap_fl_begin_polygon, METH_VARARGS, (char *)"fl_begin_polygon()"},
	 { (char *)"fl_vertex", _wrap_fl_vertex, METH_VARARGS, (char *)"fl_vertex(double x, double y)"},
	 { (char *)"fl_curve", _wrap_fl_curve, METH_VARARGS, (char *)"fl_curve(double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3)"},
	 { (char *)"fl_arc", _wrap_fl_arc, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"fl_circle", _wrap_fl_circle, METH_VARARGS, (char *)"fl_circle(double x, double y, double r)"},
	 { (char *)"fl_end_points", _wrap_fl_end_points, METH_VARARGS, (char *)"fl_end_points()"},
	 { (char *)"fl_end_line", _wrap_fl_end_line, METH_VARARGS, (char *)"fl_end_line()"},
	 { (char *)"fl_end_loop", _wrap_fl_end_loop, METH_VARARGS, (char *)"fl_end_loop()"},
	 { (char *)"fl_end_polygon", _wrap_fl_end_polygon, METH_VARARGS, (char *)"fl_end_polygon()"},
	 { (char *)"fl_begin_complex_polygon", _wrap_fl_begin_complex_polygon, METH_VARARGS, (char *)"fl_begin_complex_polygon()"},
	 { (char *)"fl_gap", _wrap_fl_gap, METH_VARARGS, (char *)"fl_gap()"},
	 { (char *)"fl_end_complex_polygon", _wrap_fl_end_complex_polygon, METH_VARARGS, (char *)"fl_end_complex_polygon()"},
	 { (char *)"fl_transform_x", _wrap_fl_transform_x, METH_VARARGS, (char *)"fl_transform_x(double x, double y) -> double"},
	 { (char *)"fl_transform_y", _wrap_fl_transform_y, METH_VARARGS, (char *)"fl_transform_y(double x, double y) -> double"},
	 { (char *)"fl_transform_dx", _wrap_fl_transform_dx, METH_VARARGS, (char *)"fl_transform_dx(double x, double y) -> double"},
	 { (char *)"fl_transform_dy", _wrap_fl_transform_dy, METH_VARARGS, (char *)"fl_transform_dy(double x, double y) -> double"},
	 { (char *)"fl_transformed_vertex", _wrap_fl_transformed_vertex, METH_VARARGS, (char *)"fl_transformed_vertex(double xf, double yf)"},
	 { (char *)"fl_font", _wrap_fl_font, METH_VARARGS, (char *)"\n"
		"fl_font(Fl_Font face, Fl_Fontsize fsize)\n"
		"fl_font() -> Fl_Font\n"
		""},
	 { (char *)"fl_size", _wrap_fl_size, METH_VARARGS, (char *)"fl_size() -> Fl_Fontsize"},
	 { (char *)"fl_height", _wrap_fl_height, METH_VARARGS, (char *)"\n"
		"fl_height() -> int\n"
		"fl_height(int font, int size) -> int\n"
		""},
	 { (char *)"fl_descent", _wrap_fl_descent, METH_VARARGS, (char *)"fl_descent() -> int"},
	 { (char *)"fl_width", _wrap_fl_width, METH_VARARGS, (char *)"\n"
		"fl_width(char const * txt) -> double\n"
		"fl_width(char const * txt, int n) -> double\n"
		"fl_width(unsigned int c) -> double\n"
		""},
	 { (char *)"fl_text_extents", _wrap_fl_text_extents, METH_VARARGS, (char *)"\n"
		"fl_text_extents(char const * arg1)\n"
		"fl_text_extents(char const * t, int n)\n"
		""},
	 { (char *)"fl_latin1_to_local", _wrap_fl_latin1_to_local, METH_VARARGS, (char *)"fl_latin1_to_local(char const * t, int n=-1) -> char const *"},
	 { (char *)"fl_local_to_latin1", _wrap_fl_local_to_latin1, METH_VARARGS, (char *)"fl_local_to_latin1(char const * t, int n=-1) -> char const *"},
	 { (char *)"fl_mac_roman_to_local", _wrap_fl_mac_roman_to_local, METH_VARARGS, (char *)"fl_mac_roman_to_local(char const * t, int n=-1) -> char const *"},
	 { (char *)"fl_local_to_mac_roman", _wrap_fl_local_to_mac_roman, METH_VARARGS, (char *)"fl_local_to_mac_roman(char const * t, int n=-1) -> char const *"},
	 { (char *)"fl_rtl_draw", _wrap_fl_rtl_draw, METH_VARARGS, (char *)"fl_rtl_draw(char const * str, int n, int x, int y)"},
	 { (char *)"fl_measure", _wrap_fl_measure, METH_VARARGS, (char *)"fl_measure(char const * str, int draw_symbols=1)"},
	 { (char *)"fl_draw", _wrap_fl_draw, METH_VARARGS, (char *)"\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, \n"
		"    int draw_symbols=1)\n"
		"fl_draw(char const * str, int x, int y, int w, int h, Fl_Align align, void (*)(char const *,int,int,int) callthis, \n"
		"    Fl_Image img=None, int draw_symbols=1)\n"
		""},
	 { (char *)"fl_frame", _wrap_fl_frame, METH_VARARGS, (char *)"\n"
		"fl_frame(Fl_Boxtype b) -> Fl_Boxtype\n"
		"fl_frame(char const * s, int x, int y, int w, int h)\n"
		""},
	 { (char *)"fl_frame2", _wrap_fl_frame2, METH_VARARGS, (char *)"fl_frame2(char const * s, int x, int y, int w, int h)"},
	 { (char *)"fl_draw_box", _wrap_fl_draw_box, METH_VARARGS, (char *)"fl_draw_box(Fl_Boxtype arg1, int x, int y, int w, int h, Fl_Color arg6)"},
	 { (char *)"fl_draw_image", _wrap_fl_draw_image, METH_VARARGS, (char *)"fl_draw_image(uchar const * buf, int X, int Y, int W, int H, int D=3, int L=0)"},
	 { (char *)"fl_draw_image_mono", _wrap_fl_draw_image_mono, METH_VARARGS, (char *)"fl_draw_image_mono(uchar const * buf, int X, int Y, int W, int H, int D=1, int L=0)"},
	 { (char *)"fl_can_do_alpha_blending", _wrap_fl_can_do_alpha_blending, METH_VARARGS, (char *)"fl_can_do_alpha_blending() -> char"},
	 { (char *)"fl_draw_pixmap", _wrap_fl_draw_pixmap, METH_VARARGS, (char *)"fl_draw_pixmap(char *const * data, int x, int y, Fl_Color arg4=) -> int"},
	 { (char *)"fl_measure_pixmap", _wrap_fl_measure_pixmap, METH_VARARGS, (char *)"fl_measure_pixmap(char *const * data) -> int"},
	 { (char *)"fl_scroll", _wrap_fl_scroll, METH_VARARGS, (char *)"\n"
		"fl_scroll(int X, int Y, int W, int H, int dx, int dy, void (*)(void *,int,int,int,int) draw_area, \n"
		"    void * data)\n"
		""},
	 { (char *)"fl_shortcut_label", _wrap_fl_shortcut_label, METH_VARARGS, (char *)"\n"
		"fl_shortcut_label(unsigned int shortcut) -> char const\n"
		"fl_shortcut_label(unsigned int shortcut, char const ** eom) -> char const *\n"
		""},
	 { (char *)"fl_overlay_rect", _wrap_fl_overlay_rect, METH_VARARGS, (char *)"fl_overlay_rect(int x, int y, int w, int h)"},
	 { (char *)"fl_overlay_clear", _wrap_fl_overlay_clear, METH_VARARGS, (char *)"fl_overlay_clear()"},
	 { (char *)"fl_cursor", _wrap_fl_cursor, METH_VARARGS, (char *)"\n"
		"fl_cursor(Fl_Cursor arg1)\n"
		"fl_cursor(Fl_Cursor arg1, Fl_Color fg, Fl_Color bg=)\n"
		""},
	 { (char *)"fl_expand_text", _wrap_fl_expand_text, METH_VARARGS, (char *)"\n"
		"fl_expand_text(char const * _from, char * buf, int maxbuf, double maxw, double & width, int wrap, \n"
		"    int draw_symbols=0) -> char const *\n"
		""},
	 { (char *)"fl_set_status", _wrap_fl_set_status, METH_VARARGS, (char *)"fl_set_status(int X, int Y, int W, int H)"},
	 { (char *)"fl_set_spot", _wrap_fl_set_spot, METH_VARARGS, (char *)"fl_set_spot(int font, int size, int X, int Y, int W, int H, Fl_Window win=None)"},
	 { (char *)"fl_reset_spot", _wrap_fl_reset_spot, METH_VARARGS, (char *)"fl_reset_spot()"},
	 { (char *)"fl_draw_symbol", _wrap_fl_draw_symbol, METH_VARARGS, (char *)"fl_draw_symbol(char const * label, int x, int y, int w, int h, Fl_Color arg6) -> int"},
	 { (char *)"fl_add_symbol", _wrap_fl_add_symbol, METH_VARARGS, (char *)"fl_add_symbol(char const * name, void (*)(Fl_Color) drawit, int scalable) -> int"},
	 { (char *)"Fl_Input__resize", _wrap_Fl_Input__resize, METH_VARARGS, (char *)"Fl_Input__resize(Fl_Input_ self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"new_Fl_Input_", _wrap_new_Fl_Input_, METH_VARARGS, (char *)"new_Fl_Input_(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Input_"},
	 { (char *)"delete_Fl_Input_", _wrap_delete_Fl_Input_, METH_VARARGS, (char *)"delete_Fl_Input_(Fl_Input_ self)"},
	 { (char *)"Fl_Input__static_value", _wrap_Fl_Input__static_value, METH_VARARGS, (char *)"\n"
		"static_value(char const * arg2) -> int\n"
		"Fl_Input__static_value(Fl_Input_ self, char const * arg2, int arg3) -> int\n"
		""},
	 { (char *)"Fl_Input__value", _wrap_Fl_Input__value, METH_VARARGS, (char *)"\n"
		"value(char const * arg2) -> int\n"
		"value(char const * arg2, int arg3) -> int\n"
		"Fl_Input__value(Fl_Input_ self) -> char const *\n"
		""},
	 { (char *)"Fl_Input__index", _wrap_Fl_Input__index, METH_VARARGS, (char *)"Fl_Input__index(Fl_Input_ self, int i) -> Fl_Char"},
	 { (char *)"Fl_Input__size", _wrap_Fl_Input__size, METH_VARARGS, (char *)"\n"
		"size() -> int\n"
		"Fl_Input__size(Fl_Input_ self, int W, int H)\n"
		""},
	 { (char *)"Fl_Input__maximum_size", _wrap_Fl_Input__maximum_size, METH_VARARGS, (char *)"\n"
		"maximum_size() -> int\n"
		"Fl_Input__maximum_size(Fl_Input_ self, int m)\n"
		""},
	 { (char *)"Fl_Input__position", _wrap_Fl_Input__position, METH_VARARGS, (char *)"\n"
		"position() -> int\n"
		"position(int p, int m) -> int\n"
		"Fl_Input__position(Fl_Input_ self, int p) -> int\n"
		""},
	 { (char *)"Fl_Input__mark", _wrap_Fl_Input__mark, METH_VARARGS, (char *)"\n"
		"mark() -> int\n"
		"Fl_Input__mark(Fl_Input_ self, int m) -> int\n"
		""},
	 { (char *)"Fl_Input__replace", _wrap_Fl_Input__replace, METH_VARARGS, (char *)"Fl_Input__replace(Fl_Input_ self, int b, int e, char const * text, int ilen=0) -> int"},
	 { (char *)"Fl_Input__cut", _wrap_Fl_Input__cut, METH_VARARGS, (char *)"\n"
		"cut() -> int\n"
		"cut(int n) -> int\n"
		"Fl_Input__cut(Fl_Input_ self, int a, int b) -> int\n"
		""},
	 { (char *)"Fl_Input__insert", _wrap_Fl_Input__insert, METH_VARARGS, (char *)"Fl_Input__insert(Fl_Input_ self, char const * t, int l=0) -> int"},
	 { (char *)"Fl_Input__copy", _wrap_Fl_Input__copy, METH_VARARGS, (char *)"Fl_Input__copy(Fl_Input_ self, int clipboard) -> int"},
	 { (char *)"Fl_Input__undo", _wrap_Fl_Input__undo, METH_VARARGS, (char *)"Fl_Input__undo(Fl_Input_ self) -> int"},
	 { (char *)"Fl_Input__copy_cuts", _wrap_Fl_Input__copy_cuts, METH_VARARGS, (char *)"Fl_Input__copy_cuts(Fl_Input_ self) -> int"},
	 { (char *)"Fl_Input__shortcut", _wrap_Fl_Input__shortcut, METH_VARARGS, (char *)"\n"
		"shortcut() -> int\n"
		"Fl_Input__shortcut(Fl_Input_ self, int s)\n"
		""},
	 { (char *)"Fl_Input__textfont", _wrap_Fl_Input__textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Input__textfont(Fl_Input_ self, Fl_Font s)\n"
		""},
	 { (char *)"Fl_Input__textsize", _wrap_Fl_Input__textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Input__textsize(Fl_Input_ self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Input__textcolor", _wrap_Fl_Input__textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Input__textcolor(Fl_Input_ self, Fl_Color n)\n"
		""},
	 { (char *)"Fl_Input__cursor_color", _wrap_Fl_Input__cursor_color, METH_VARARGS, (char *)"\n"
		"cursor_color() -> Fl_Color\n"
		"Fl_Input__cursor_color(Fl_Input_ self, Fl_Color n)\n"
		""},
	 { (char *)"Fl_Input__input_type", _wrap_Fl_Input__input_type, METH_VARARGS, (char *)"\n"
		"input_type() -> int\n"
		"Fl_Input__input_type(Fl_Input_ self, int t)\n"
		""},
	 { (char *)"Fl_Input__readonly", _wrap_Fl_Input__readonly, METH_VARARGS, (char *)"\n"
		"readonly() -> int\n"
		"Fl_Input__readonly(Fl_Input_ self, int b)\n"
		""},
	 { (char *)"Fl_Input__wrap", _wrap_Fl_Input__wrap, METH_VARARGS, (char *)"\n"
		"wrap() -> int\n"
		"Fl_Input__wrap(Fl_Input_ self, int b)\n"
		""},
	 { (char *)"Fl_Input__tab_nav", _wrap_Fl_Input__tab_nav, METH_VARARGS, (char *)"\n"
		"tab_nav(int val)\n"
		"Fl_Input__tab_nav(Fl_Input_ self) -> int\n"
		""},
	 { (char *)"disown_Fl_Input_", _wrap_disown_Fl_Input_, METH_VARARGS, NULL},
	 { (char *)"Fl_Input__swigregister", Fl_Input__swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Input_draw", _wrap_Fl_Input_draw, METH_VARARGS, (char *)"Fl_Input_draw(Fl_Input self)"},
	 { (char *)"Fl_Input_handle", _wrap_Fl_Input_handle, METH_VARARGS, (char *)"Fl_Input_handle(Fl_Input self, int arg0) -> int"},
	 { (char *)"new_Fl_Input", _wrap_new_Fl_Input, METH_VARARGS, (char *)"new_Fl_Input(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Input"},
	 { (char *)"delete_Fl_Input", _wrap_delete_Fl_Input, METH_VARARGS, (char *)"delete_Fl_Input(Fl_Input self)"},
	 { (char *)"disown_Fl_Input", _wrap_disown_Fl_Input, METH_VARARGS, NULL},
	 { (char *)"Fl_Input_swigregister", Fl_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_File_Input", _wrap_new_Fl_File_Input, METH_VARARGS, (char *)"new_Fl_File_Input(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_File_Input"},
	 { (char *)"Fl_File_Input_handle", _wrap_Fl_File_Input_handle, METH_VARARGS, (char *)"Fl_File_Input_handle(Fl_File_Input self, int event) -> int"},
	 { (char *)"Fl_File_Input_draw", _wrap_Fl_File_Input_draw, METH_VARARGS, (char *)"Fl_File_Input_draw(Fl_File_Input self)"},
	 { (char *)"Fl_File_Input_down_box", _wrap_Fl_File_Input_down_box, METH_VARARGS, (char *)"\n"
		"down_box() -> Fl_Boxtype\n"
		"Fl_File_Input_down_box(Fl_File_Input self, Fl_Boxtype b)\n"
		""},
	 { (char *)"Fl_File_Input_errorcolor", _wrap_Fl_File_Input_errorcolor, METH_VARARGS, (char *)"\n"
		"errorcolor() -> Fl_Color\n"
		"Fl_File_Input_errorcolor(Fl_File_Input self, Fl_Color c)\n"
		""},
	 { (char *)"Fl_File_Input_value", _wrap_Fl_File_Input_value, METH_VARARGS, (char *)"\n"
		"value(char const * str) -> int\n"
		"value(char const * str, int len) -> int\n"
		"Fl_File_Input_value(Fl_File_Input self) -> char const *\n"
		""},
	 { (char *)"delete_Fl_File_Input", _wrap_delete_Fl_File_Input, METH_VARARGS, (char *)"delete_Fl_File_Input(Fl_File_Input self)"},
	 { (char *)"disown_Fl_File_Input", _wrap_disown_Fl_File_Input, METH_VARARGS, NULL},
	 { (char *)"Fl_File_Input_swigregister", Fl_File_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Fill_Dial", _wrap_new_Fl_Fill_Dial, METH_VARARGS, (char *)"new_Fl_Fill_Dial(PyObject * self, int X, int Y, int W, int H, char const * L) -> Fl_Fill_Dial"},
	 { (char *)"delete_Fl_Fill_Dial", _wrap_delete_Fl_Fill_Dial, METH_VARARGS, (char *)"delete_Fl_Fill_Dial(Fl_Fill_Dial self)"},
	 { (char *)"disown_Fl_Fill_Dial", _wrap_disown_Fl_Fill_Dial, METH_VARARGS, NULL},
	 { (char *)"Fl_Fill_Dial_draw", _wrap_Fl_Fill_Dial_draw, METH_VARARGS, (char *)"Fl_Fill_Dial_draw(Fl_Fill_Dial self)"},
	 { (char *)"Fl_Fill_Dial_swigregister", Fl_Fill_Dial_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Slider_draw", _wrap_Fl_Slider_draw, METH_VARARGS, (char *)"Fl_Slider_draw(Fl_Slider self)"},
	 { (char *)"Fl_Slider_handle", _wrap_Fl_Slider_handle, METH_VARARGS, (char *)"Fl_Slider_handle(Fl_Slider self, int arg0) -> int"},
	 { (char *)"new_Fl_Slider", _wrap_new_Fl_Slider, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Slider_scrollvalue", _wrap_Fl_Slider_scrollvalue, METH_VARARGS, (char *)"Fl_Slider_scrollvalue(Fl_Slider self, int pos, int size, int first, int total) -> int"},
	 { (char *)"Fl_Slider_bounds", _wrap_Fl_Slider_bounds, METH_VARARGS, (char *)"Fl_Slider_bounds(Fl_Slider self, double a, double b)"},
	 { (char *)"Fl_Slider_slider_size", _wrap_Fl_Slider_slider_size, METH_VARARGS, (char *)"\n"
		"slider_size() -> float\n"
		"Fl_Slider_slider_size(Fl_Slider self, double v)\n"
		""},
	 { (char *)"Fl_Slider_slider", _wrap_Fl_Slider_slider, METH_VARARGS, (char *)"\n"
		"slider() -> Fl_Boxtype\n"
		"Fl_Slider_slider(Fl_Slider self, Fl_Boxtype c)\n"
		""},
	 { (char *)"delete_Fl_Slider", _wrap_delete_Fl_Slider, METH_VARARGS, (char *)"delete_Fl_Slider(Fl_Slider self)"},
	 { (char *)"disown_Fl_Slider", _wrap_disown_Fl_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Slider_swigregister", Fl_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Fill_Slider", _wrap_new_Fl_Fill_Slider, METH_VARARGS, (char *)"new_Fl_Fill_Slider(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Fill_Slider"},
	 { (char *)"delete_Fl_Fill_Slider", _wrap_delete_Fl_Fill_Slider, METH_VARARGS, (char *)"delete_Fl_Fill_Slider(Fl_Fill_Slider self)"},
	 { (char *)"disown_Fl_Fill_Slider", _wrap_disown_Fl_Fill_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Fill_Slider_draw", _wrap_Fl_Fill_Slider_draw, METH_VARARGS, (char *)"Fl_Fill_Slider_draw(Fl_Fill_Slider self)"},
	 { (char *)"Fl_Fill_Slider_swigregister", Fl_Fill_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Float_Input", _wrap_new_Fl_Float_Input, METH_VARARGS, (char *)"new_Fl_Float_Input(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Float_Input"},
	 { (char *)"delete_Fl_Float_Input", _wrap_delete_Fl_Float_Input, METH_VARARGS, (char *)"delete_Fl_Float_Input(Fl_Float_Input self)"},
	 { (char *)"disown_Fl_Float_Input", _wrap_disown_Fl_Float_Input, METH_VARARGS, NULL},
	 { (char *)"Fl_Float_Input_draw", _wrap_Fl_Float_Input_draw, METH_VARARGS, (char *)"Fl_Float_Input_draw(Fl_Float_Input self)"},
	 { (char *)"Fl_Float_Input_swigregister", Fl_Float_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_FormsBitmap_draw", _wrap_Fl_FormsBitmap_draw, METH_VARARGS, (char *)"Fl_FormsBitmap_draw(Fl_FormsBitmap self)"},
	 { (char *)"new_Fl_FormsBitmap", _wrap_new_Fl_FormsBitmap, METH_VARARGS, (char *)"new_Fl_FormsBitmap(PyObject * self, Fl_Boxtype arg2, int arg3, int arg4, int arg5, int arg6, char const * arg7=None) -> Fl_FormsBitmap"},
	 { (char *)"Fl_FormsBitmap_set", _wrap_Fl_FormsBitmap_set, METH_VARARGS, (char *)"Fl_FormsBitmap_set(Fl_FormsBitmap self, int W, int H, uchar const * bits)"},
	 { (char *)"Fl_FormsBitmap_bitmap", _wrap_Fl_FormsBitmap_bitmap, METH_VARARGS, (char *)"\n"
		"bitmap(Fl_Bitmap B)\n"
		"Fl_FormsBitmap_bitmap(Fl_FormsBitmap self) -> Fl_Bitmap\n"
		""},
	 { (char *)"delete_Fl_FormsBitmap", _wrap_delete_Fl_FormsBitmap, METH_VARARGS, (char *)"delete_Fl_FormsBitmap(Fl_FormsBitmap self)"},
	 { (char *)"disown_Fl_FormsBitmap", _wrap_disown_Fl_FormsBitmap, METH_VARARGS, NULL},
	 { (char *)"Fl_FormsBitmap_swigregister", Fl_FormsBitmap_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_FormsPixmap_draw", _wrap_Fl_FormsPixmap_draw, METH_VARARGS, (char *)"Fl_FormsPixmap_draw(Fl_FormsPixmap self)"},
	 { (char *)"new_Fl_FormsPixmap", _wrap_new_Fl_FormsPixmap, METH_VARARGS, (char *)"new_Fl_FormsPixmap(PyObject * self, Fl_Boxtype t, int X, int Y, int W, int H, char const * L=None) -> Fl_FormsPixmap"},
	 { (char *)"Fl_FormsPixmap_set", _wrap_Fl_FormsPixmap_set, METH_VARARGS, (char *)"Fl_FormsPixmap_set(Fl_FormsPixmap self, char *const * bits)"},
	 { (char *)"Fl_FormsPixmap_Pixmap", _wrap_Fl_FormsPixmap_Pixmap, METH_VARARGS, (char *)"\n"
		"Pixmap(Fl_Pixmap B)\n"
		"Fl_FormsPixmap_Pixmap(Fl_FormsPixmap self) -> Fl_Pixmap\n"
		""},
	 { (char *)"delete_Fl_FormsPixmap", _wrap_delete_Fl_FormsPixmap, METH_VARARGS, (char *)"delete_Fl_FormsPixmap(Fl_FormsPixmap self)"},
	 { (char *)"disown_Fl_FormsPixmap", _wrap_disown_Fl_FormsPixmap, METH_VARARGS, NULL},
	 { (char *)"Fl_FormsPixmap_swigregister", Fl_FormsPixmap_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Free_draw", _wrap_Fl_Free_draw, METH_VARARGS, (char *)"Fl_Free_draw(Fl_Free self)"},
	 { (char *)"Fl_Free_handle", _wrap_Fl_Free_handle, METH_VARARGS, (char *)"Fl_Free_handle(Fl_Free self, int e) -> int"},
	 { (char *)"new_Fl_Free", _wrap_new_Fl_Free, METH_VARARGS, (char *)"new_Fl_Free(PyObject * self, uchar t, int X, int Y, int W, int H, char const * L, FL_HANDLEPTR hdl) -> Fl_Free"},
	 { (char *)"delete_Fl_Free", _wrap_delete_Fl_Free, METH_VARARGS, (char *)"delete_Fl_Free(Fl_Free self)"},
	 { (char *)"disown_Fl_Free", _wrap_disown_Fl_Free, METH_VARARGS, NULL},
	 { (char *)"Fl_Free_swigregister", Fl_Free_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Pixmap", _wrap_new_Fl_Pixmap, METH_VARARGS, (char *)"new_Fl_Pixmap(PyObject * self, char const *const * D) -> Fl_Pixmap"},
	 { (char *)"delete_Fl_Pixmap", _wrap_delete_Fl_Pixmap, METH_VARARGS, (char *)"delete_Fl_Pixmap(Fl_Pixmap self)"},
	 { (char *)"Fl_Pixmap_copy", _wrap_Fl_Pixmap_copy, METH_VARARGS, (char *)"\n"
		"copy(int W, int H) -> Fl_Image\n"
		"Fl_Pixmap_copy(Fl_Pixmap self) -> Fl_Image\n"
		""},
	 { (char *)"Fl_Pixmap_color_average", _wrap_Fl_Pixmap_color_average, METH_VARARGS, (char *)"Fl_Pixmap_color_average(Fl_Pixmap self, Fl_Color c, float i)"},
	 { (char *)"Fl_Pixmap_desaturate", _wrap_Fl_Pixmap_desaturate, METH_VARARGS, (char *)"Fl_Pixmap_desaturate(Fl_Pixmap self)"},
	 { (char *)"Fl_Pixmap_draw", _wrap_Fl_Pixmap_draw, METH_VARARGS, (char *)"\n"
		"draw(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"
		""},
	 { (char *)"Fl_Pixmap_label", _wrap_Fl_Pixmap_label, METH_VARARGS, (char *)"\n"
		"label(Fl_Widget w)\n"
		"Fl_Pixmap_label(Fl_Pixmap self, Fl_Menu_Item m)\n"
		""},
	 { (char *)"Fl_Pixmap_uncache", _wrap_Fl_Pixmap_uncache, METH_VARARGS, (char *)"Fl_Pixmap_uncache(Fl_Pixmap self)"},
	 { (char *)"disown_Fl_Pixmap", _wrap_disown_Fl_Pixmap, METH_VARARGS, NULL},
	 { (char *)"Fl_Pixmap_swigregister", Fl_Pixmap_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_GIF_Image", _wrap_new_Fl_GIF_Image, METH_VARARGS, (char *)"new_Fl_GIF_Image(PyObject * self, char const * filename) -> Fl_GIF_Image"},
	 { (char *)"delete_Fl_GIF_Image", _wrap_delete_Fl_GIF_Image, METH_VARARGS, (char *)"delete_Fl_GIF_Image(Fl_GIF_Image self)"},
	 { (char *)"disown_Fl_GIF_Image", _wrap_disown_Fl_GIF_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_GIF_Image_swigregister", Fl_GIF_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Gl_Window_flush", _wrap_Fl_Gl_Window_flush, METH_VARARGS, (char *)"Fl_Gl_Window_flush(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_hide", _wrap_Fl_Gl_Window_hide, METH_VARARGS, (char *)"Fl_Gl_Window_hide(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_resize", _wrap_Fl_Gl_Window_resize, METH_VARARGS, (char *)"Fl_Gl_Window_resize(Fl_Gl_Window self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"Fl_Gl_Window_handle", _wrap_Fl_Gl_Window_handle, METH_VARARGS, (char *)"Fl_Gl_Window_handle(Fl_Gl_Window self, int arg0) -> int"},
	 { (char *)"Fl_Gl_Window_valid", _wrap_Fl_Gl_Window_valid, METH_VARARGS, (char *)"\n"
		"valid() -> char\n"
		"Fl_Gl_Window_valid(Fl_Gl_Window self, char v)\n"
		""},
	 { (char *)"Fl_Gl_Window_invalidate", _wrap_Fl_Gl_Window_invalidate, METH_VARARGS, (char *)"Fl_Gl_Window_invalidate(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_context_valid", _wrap_Fl_Gl_Window_context_valid, METH_VARARGS, (char *)"\n"
		"context_valid() -> char\n"
		"Fl_Gl_Window_context_valid(Fl_Gl_Window self, char v)\n"
		""},
	 { (char *)"Fl_Gl_Window_can_do", _wrap_Fl_Gl_Window_can_do, METH_VARARGS, (char *)"\n"
		"can_do(int m) -> int\n"
		"can_do(int const * m) -> int\n"
		"Fl_Gl_Window_can_do(Fl_Gl_Window self) -> int\n"
		""},
	 { (char *)"Fl_Gl_Window_mode", _wrap_Fl_Gl_Window_mode, METH_VARARGS, (char *)"\n"
		"mode() -> Fl_Mode\n"
		"mode(int a) -> int\n"
		"Fl_Gl_Window_mode(Fl_Gl_Window self, int const * a) -> int\n"
		""},
	 { (char *)"Fl_Gl_Window_context", _wrap_Fl_Gl_Window_context, METH_VARARGS, (char *)"\n"
		"context()\n"
		"Fl_Gl_Window_context(Fl_Gl_Window self, void * arg2, int destroy_flag=0)\n"
		""},
	 { (char *)"Fl_Gl_Window_make_current", _wrap_Fl_Gl_Window_make_current, METH_VARARGS, (char *)"Fl_Gl_Window_make_current(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_swap_buffers", _wrap_Fl_Gl_Window_swap_buffers, METH_VARARGS, (char *)"Fl_Gl_Window_swap_buffers(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_ortho", _wrap_Fl_Gl_Window_ortho, METH_VARARGS, (char *)"Fl_Gl_Window_ortho(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_can_do_overlay", _wrap_Fl_Gl_Window_can_do_overlay, METH_VARARGS, (char *)"Fl_Gl_Window_can_do_overlay(Fl_Gl_Window self) -> int"},
	 { (char *)"Fl_Gl_Window_redraw_overlay", _wrap_Fl_Gl_Window_redraw_overlay, METH_VARARGS, (char *)"Fl_Gl_Window_redraw_overlay(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_hide_overlay", _wrap_Fl_Gl_Window_hide_overlay, METH_VARARGS, (char *)"Fl_Gl_Window_hide_overlay(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_make_overlay_current", _wrap_Fl_Gl_Window_make_overlay_current, METH_VARARGS, (char *)"Fl_Gl_Window_make_overlay_current(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_as_gl_window", _wrap_Fl_Gl_Window_as_gl_window, METH_VARARGS, (char *)"Fl_Gl_Window_as_gl_window(Fl_Gl_Window self) -> Fl_Gl_Window"},
	 { (char *)"Fl_Gl_Window_pixels_per_unit", _wrap_Fl_Gl_Window_pixels_per_unit, METH_VARARGS, (char *)"Fl_Gl_Window_pixels_per_unit(Fl_Gl_Window self) -> float"},
	 { (char *)"Fl_Gl_Window_pixel_w", _wrap_Fl_Gl_Window_pixel_w, METH_VARARGS, (char *)"Fl_Gl_Window_pixel_w(Fl_Gl_Window self) -> int"},
	 { (char *)"Fl_Gl_Window_pixel_h", _wrap_Fl_Gl_Window_pixel_h, METH_VARARGS, (char *)"Fl_Gl_Window_pixel_h(Fl_Gl_Window self) -> int"},
	 { (char *)"delete_Fl_Gl_Window", _wrap_delete_Fl_Gl_Window, METH_VARARGS, (char *)"delete_Fl_Gl_Window(Fl_Gl_Window self)"},
	 { (char *)"new_Fl_Gl_Window", _wrap_new_Fl_Gl_Window, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Gl_Window_draw", _wrap_Fl_Gl_Window_draw, METH_VARARGS, (char *)"Fl_Gl_Window_draw(Fl_Gl_Window self)"},
	 { (char *)"Fl_Gl_Window_show", _wrap_Fl_Gl_Window_show, METH_VARARGS, (char *)"Fl_Gl_Window_show(Fl_Gl_Window self, PyObject * count=None, PyObject * data=None)"},
	 { (char *)"Fl_Gl_Window_drawPixels", _wrap_Fl_Gl_Window_drawPixels, METH_VARARGS, (char *)"\n"
		"Fl_Gl_Window_drawPixels(Fl_Gl_Window self, PyObject * rgb_py)\n"
		"\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"
		""},
	 { (char *)"disown_Fl_Gl_Window", _wrap_disown_Fl_Gl_Window, METH_VARARGS, NULL},
	 { (char *)"Fl_Gl_Window_swigregister", Fl_Gl_Window_swigregister, METH_VARARGS, NULL},
	 { (char *)"gl_start", _wrap_gl_start, METH_VARARGS, (char *)"gl_start()"},
	 { (char *)"gl_finish", _wrap_gl_finish, METH_VARARGS, (char *)"gl_finish()"},
	 { (char *)"gl_color", _wrap_gl_color, METH_VARARGS, (char *)"\n"
		"gl_color(Fl_Color i)\n"
		"gl_color(int c)\n"
		""},
	 { (char *)"gl_rect", _wrap_gl_rect, METH_VARARGS, (char *)"gl_rect(int x, int y, int w, int h)"},
	 { (char *)"gl_rectf", _wrap_gl_rectf, METH_VARARGS, (char *)"gl_rectf(int x, int y, int w, int h)"},
	 { (char *)"gl_font", _wrap_gl_font, METH_VARARGS, (char *)"gl_font(int fontid, int size)"},
	 { (char *)"gl_height", _wrap_gl_height, METH_VARARGS, (char *)"gl_height() -> int"},
	 { (char *)"gl_descent", _wrap_gl_descent, METH_VARARGS, (char *)"gl_descent() -> int"},
	 { (char *)"gl_width", _wrap_gl_width, METH_VARARGS, (char *)"\n"
		"gl_width(char const * arg1) -> double\n"
		"gl_width(char const * arg1, int n) -> double\n"
		"gl_width(uchar arg1) -> double\n"
		""},
	 { (char *)"gl_draw", _wrap_gl_draw, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"gl_measure", _wrap_gl_measure, METH_VARARGS, (char *)"gl_measure(char const * arg1)"},
	 { (char *)"gl_draw_image", _wrap_gl_draw_image, METH_VARARGS, (char *)"gl_draw_image(uchar const * arg1, int x, int y, int w, int h, int d=3, int ld=0)"},
	 { (char *)"new_Fl_Help_Dialog", _wrap_new_Fl_Help_Dialog, METH_VARARGS, (char *)"new_Fl_Help_Dialog() -> Fl_Help_Dialog"},
	 { (char *)"delete_Fl_Help_Dialog", _wrap_delete_Fl_Help_Dialog, METH_VARARGS, (char *)"delete_Fl_Help_Dialog(Fl_Help_Dialog self)"},
	 { (char *)"Fl_Help_Dialog_h", _wrap_Fl_Help_Dialog_h, METH_VARARGS, (char *)"Fl_Help_Dialog_h(Fl_Help_Dialog self) -> int"},
	 { (char *)"Fl_Help_Dialog_hide", _wrap_Fl_Help_Dialog_hide, METH_VARARGS, (char *)"Fl_Help_Dialog_hide(Fl_Help_Dialog self)"},
	 { (char *)"Fl_Help_Dialog_load", _wrap_Fl_Help_Dialog_load, METH_VARARGS, (char *)"Fl_Help_Dialog_load(Fl_Help_Dialog self, char const * f)"},
	 { (char *)"Fl_Help_Dialog_position", _wrap_Fl_Help_Dialog_position, METH_VARARGS, (char *)"Fl_Help_Dialog_position(Fl_Help_Dialog self, int xx, int yy)"},
	 { (char *)"Fl_Help_Dialog_resize", _wrap_Fl_Help_Dialog_resize, METH_VARARGS, (char *)"Fl_Help_Dialog_resize(Fl_Help_Dialog self, int xx, int yy, int ww, int hh)"},
	 { (char *)"Fl_Help_Dialog_show", _wrap_Fl_Help_Dialog_show, METH_VARARGS, (char *)"\n"
		"show()\n"
		"Fl_Help_Dialog_show(Fl_Help_Dialog self, int argc, char ** argv)\n"
		""},
	 { (char *)"Fl_Help_Dialog_textsize", _wrap_Fl_Help_Dialog_textsize, METH_VARARGS, (char *)"\n"
		"textsize(Fl_Fontsize s)\n"
		"Fl_Help_Dialog_textsize(Fl_Help_Dialog self) -> Fl_Fontsize\n"
		""},
	 { (char *)"Fl_Help_Dialog_topline", _wrap_Fl_Help_Dialog_topline, METH_VARARGS, (char *)"\n"
		"topline(char const * n)\n"
		"Fl_Help_Dialog_topline(Fl_Help_Dialog self, int n)\n"
		""},
	 { (char *)"Fl_Help_Dialog_value", _wrap_Fl_Help_Dialog_value, METH_VARARGS, (char *)"\n"
		"value(char const * f)\n"
		"Fl_Help_Dialog_value(Fl_Help_Dialog self) -> char const *\n"
		""},
	 { (char *)"Fl_Help_Dialog_visible", _wrap_Fl_Help_Dialog_visible, METH_VARARGS, (char *)"Fl_Help_Dialog_visible(Fl_Help_Dialog self) -> int"},
	 { (char *)"Fl_Help_Dialog_w", _wrap_Fl_Help_Dialog_w, METH_VARARGS, (char *)"Fl_Help_Dialog_w(Fl_Help_Dialog self) -> int"},
	 { (char *)"Fl_Help_Dialog_x", _wrap_Fl_Help_Dialog_x, METH_VARARGS, (char *)"Fl_Help_Dialog_x(Fl_Help_Dialog self) -> int"},
	 { (char *)"Fl_Help_Dialog_y", _wrap_Fl_Help_Dialog_y, METH_VARARGS, (char *)"Fl_Help_Dialog_y(Fl_Help_Dialog self) -> int"},
	 { (char *)"Fl_Help_Dialog_swigregister", Fl_Help_Dialog_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Help_Block", _wrap_new_Fl_Help_Block, METH_VARARGS, (char *)"new_Fl_Help_Block() -> Fl_Help_Block"},
	 { (char *)"delete_Fl_Help_Block", _wrap_delete_Fl_Help_Block, METH_VARARGS, (char *)"delete_Fl_Help_Block(Fl_Help_Block self)"},
	 { (char *)"Fl_Help_Block_swigregister", Fl_Help_Block_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Help_Link", _wrap_new_Fl_Help_Link, METH_VARARGS, (char *)"new_Fl_Help_Link() -> Fl_Help_Link"},
	 { (char *)"delete_Fl_Help_Link", _wrap_delete_Fl_Help_Link, METH_VARARGS, (char *)"delete_Fl_Help_Link(Fl_Help_Link self)"},
	 { (char *)"Fl_Help_Link_swigregister", Fl_Help_Link_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Help_Font_Style_get", _wrap_Fl_Help_Font_Style_get, METH_VARARGS, (char *)"Fl_Help_Font_Style_get(Fl_Help_Font_Style self, Fl_Color & acolor)"},
	 { (char *)"Fl_Help_Font_Style_set", _wrap_Fl_Help_Font_Style_set, METH_VARARGS, (char *)"Fl_Help_Font_Style_set(Fl_Help_Font_Style self, Fl_Font afont, Fl_Fontsize asize, Fl_Color acolor)"},
	 { (char *)"new_Fl_Help_Font_Style", _wrap_new_Fl_Help_Font_Style, METH_VARARGS, (char *)"\n"
		"Fl_Help_Font_Style(Fl_Font afont, Fl_Fontsize asize, Fl_Color acolor)\n"
		"new_Fl_Help_Font_Style() -> Fl_Help_Font_Style\n"
		""},
	 { (char *)"delete_Fl_Help_Font_Style", _wrap_delete_Fl_Help_Font_Style, METH_VARARGS, (char *)"delete_Fl_Help_Font_Style(Fl_Help_Font_Style self)"},
	 { (char *)"Fl_Help_Font_Style_swigregister", Fl_Help_Font_Style_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Help_Font_Stack", _wrap_new_Fl_Help_Font_Stack, METH_VARARGS, (char *)"new_Fl_Help_Font_Stack() -> Fl_Help_Font_Stack"},
	 { (char *)"Fl_Help_Font_Stack_init", _wrap_Fl_Help_Font_Stack_init, METH_VARARGS, (char *)"Fl_Help_Font_Stack_init(Fl_Help_Font_Stack self, Fl_Font f, Fl_Fontsize s, Fl_Color c)"},
	 { (char *)"Fl_Help_Font_Stack_top", _wrap_Fl_Help_Font_Stack_top, METH_VARARGS, (char *)"Fl_Help_Font_Stack_top(Fl_Help_Font_Stack self, Fl_Color & c)"},
	 { (char *)"Fl_Help_Font_Stack_push", _wrap_Fl_Help_Font_Stack_push, METH_VARARGS, (char *)"Fl_Help_Font_Stack_push(Fl_Help_Font_Stack self, Fl_Font f, Fl_Fontsize s, Fl_Color c)"},
	 { (char *)"Fl_Help_Font_Stack_pop", _wrap_Fl_Help_Font_Stack_pop, METH_VARARGS, (char *)"Fl_Help_Font_Stack_pop(Fl_Help_Font_Stack self, Fl_Color & c)"},
	 { (char *)"Fl_Help_Font_Stack_count", _wrap_Fl_Help_Font_Stack_count, METH_VARARGS, (char *)"Fl_Help_Font_Stack_count(Fl_Help_Font_Stack self) -> size_t"},
	 { (char *)"delete_Fl_Help_Font_Stack", _wrap_delete_Fl_Help_Font_Stack, METH_VARARGS, (char *)"delete_Fl_Help_Font_Stack(Fl_Help_Font_Stack self)"},
	 { (char *)"Fl_Help_Font_Stack_swigregister", Fl_Help_Font_Stack_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Help_Target", _wrap_new_Fl_Help_Target, METH_VARARGS, (char *)"new_Fl_Help_Target() -> Fl_Help_Target"},
	 { (char *)"delete_Fl_Help_Target", _wrap_delete_Fl_Help_Target, METH_VARARGS, (char *)"delete_Fl_Help_Target(Fl_Help_Target self)"},
	 { (char *)"Fl_Help_Target_swigregister", Fl_Help_Target_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Help_View", _wrap_new_Fl_Help_View, METH_VARARGS, (char *)"new_Fl_Help_View(PyObject * self, int xx, int yy, int ww, int hh, char const * l=None) -> Fl_Help_View"},
	 { (char *)"delete_Fl_Help_View", _wrap_delete_Fl_Help_View, METH_VARARGS, (char *)"delete_Fl_Help_View(Fl_Help_View self)"},
	 { (char *)"Fl_Help_View_directory", _wrap_Fl_Help_View_directory, METH_VARARGS, (char *)"Fl_Help_View_directory(Fl_Help_View self) -> char const *"},
	 { (char *)"Fl_Help_View_filename", _wrap_Fl_Help_View_filename, METH_VARARGS, (char *)"Fl_Help_View_filename(Fl_Help_View self) -> char const *"},
	 { (char *)"Fl_Help_View_find", _wrap_Fl_Help_View_find, METH_VARARGS, (char *)"Fl_Help_View_find(Fl_Help_View self, char const * s, int p=0) -> int"},
	 { (char *)"Fl_Help_View_load", _wrap_Fl_Help_View_load, METH_VARARGS, (char *)"Fl_Help_View_load(Fl_Help_View self, char const * f) -> int"},
	 { (char *)"Fl_Help_View_resize", _wrap_Fl_Help_View_resize, METH_VARARGS, (char *)"Fl_Help_View_resize(Fl_Help_View self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"Fl_Help_View_size", _wrap_Fl_Help_View_size, METH_VARARGS, (char *)"\n"
		"size() -> int\n"
		"Fl_Help_View_size(Fl_Help_View self, int W, int H)\n"
		""},
	 { (char *)"Fl_Help_View_textcolor", _wrap_Fl_Help_View_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor(Fl_Color c)\n"
		"Fl_Help_View_textcolor(Fl_Help_View self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Help_View_textfont", _wrap_Fl_Help_View_textfont, METH_VARARGS, (char *)"\n"
		"textfont(Fl_Font f)\n"
		"Fl_Help_View_textfont(Fl_Help_View self) -> Fl_Font\n"
		""},
	 { (char *)"Fl_Help_View_textsize", _wrap_Fl_Help_View_textsize, METH_VARARGS, (char *)"\n"
		"textsize(Fl_Fontsize s)\n"
		"Fl_Help_View_textsize(Fl_Help_View self) -> Fl_Fontsize\n"
		""},
	 { (char *)"Fl_Help_View_title", _wrap_Fl_Help_View_title, METH_VARARGS, (char *)"Fl_Help_View_title(Fl_Help_View self) -> char const *"},
	 { (char *)"Fl_Help_View_topline", _wrap_Fl_Help_View_topline, METH_VARARGS, (char *)"\n"
		"topline(char const * n)\n"
		"topline(int arg2)\n"
		"Fl_Help_View_topline(Fl_Help_View self) -> int\n"
		""},
	 { (char *)"Fl_Help_View_leftline", _wrap_Fl_Help_View_leftline, METH_VARARGS, (char *)"\n"
		"leftline(int arg2)\n"
		"Fl_Help_View_leftline(Fl_Help_View self) -> int\n"
		""},
	 { (char *)"Fl_Help_View_value", _wrap_Fl_Help_View_value, METH_VARARGS, (char *)"\n"
		"value(char const * val)\n"
		"Fl_Help_View_value(Fl_Help_View self) -> char const *\n"
		""},
	 { (char *)"Fl_Help_View_clear_selection", _wrap_Fl_Help_View_clear_selection, METH_VARARGS, (char *)"Fl_Help_View_clear_selection(Fl_Help_View self)"},
	 { (char *)"Fl_Help_View_select_all", _wrap_Fl_Help_View_select_all, METH_VARARGS, (char *)"Fl_Help_View_select_all(Fl_Help_View self)"},
	 { (char *)"Fl_Help_View_scrollbar_size", _wrap_Fl_Help_View_scrollbar_size, METH_VARARGS, (char *)"\n"
		"scrollbar_size() -> int\n"
		"Fl_Help_View_scrollbar_size(Fl_Help_View self, int newSize)\n"
		""},
	 { (char *)"Fl_Help_View_link", _wrap_Fl_Help_View_link, METH_VARARGS, (char *)"\n"
		"link(Fl_Help_Func * fn)\n"
		"Fl_Help_View_link(Fl_Help_View self, PyObject * PyFunc, PyObject * PyWidget)\n"
		""},
	 { (char *)"disown_Fl_Help_View", _wrap_disown_Fl_Help_View, METH_VARARGS, NULL},
	 { (char *)"Fl_Help_View_draw", _wrap_Fl_Help_View_draw, METH_VARARGS, (char *)"Fl_Help_View_draw(Fl_Help_View self)"},
	 { (char *)"Fl_Help_View_swigregister", Fl_Help_View_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Hold_Browser", _wrap_new_Fl_Hold_Browser, METH_VARARGS, (char *)"new_Fl_Hold_Browser(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hold_Browser"},
	 { (char *)"delete_Fl_Hold_Browser", _wrap_delete_Fl_Hold_Browser, METH_VARARGS, (char *)"delete_Fl_Hold_Browser(Fl_Hold_Browser self)"},
	 { (char *)"disown_Fl_Hold_Browser", _wrap_disown_Fl_Hold_Browser, METH_VARARGS, NULL},
	 { (char *)"Fl_Hold_Browser_draw", _wrap_Fl_Hold_Browser_draw, METH_VARARGS, (char *)"Fl_Hold_Browser_draw(Fl_Hold_Browser self)"},
	 { (char *)"Fl_Hold_Browser_item_first", _wrap_Fl_Hold_Browser_item_first, METH_VARARGS, (char *)"Fl_Hold_Browser_item_first(Fl_Hold_Browser self) -> void *"},
	 { (char *)"Fl_Hold_Browser_item_next", _wrap_Fl_Hold_Browser_item_next, METH_VARARGS, (char *)"Fl_Hold_Browser_item_next(Fl_Hold_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Hold_Browser_item_prev", _wrap_Fl_Hold_Browser_item_prev, METH_VARARGS, (char *)"Fl_Hold_Browser_item_prev(Fl_Hold_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Hold_Browser_item_last", _wrap_Fl_Hold_Browser_item_last, METH_VARARGS, (char *)"Fl_Hold_Browser_item_last(Fl_Hold_Browser self) -> void *"},
	 { (char *)"Fl_Hold_Browser_item_height", _wrap_Fl_Hold_Browser_item_height, METH_VARARGS, (char *)"Fl_Hold_Browser_item_height(Fl_Hold_Browser self, void * item) -> int"},
	 { (char *)"Fl_Hold_Browser_item_width", _wrap_Fl_Hold_Browser_item_width, METH_VARARGS, (char *)"Fl_Hold_Browser_item_width(Fl_Hold_Browser self, void * item) -> int"},
	 { (char *)"Fl_Hold_Browser_item_quick_height", _wrap_Fl_Hold_Browser_item_quick_height, METH_VARARGS, (char *)"Fl_Hold_Browser_item_quick_height(Fl_Hold_Browser self, void * item) -> int"},
	 { (char *)"Fl_Hold_Browser_item_draw", _wrap_Fl_Hold_Browser_item_draw, METH_VARARGS, (char *)"Fl_Hold_Browser_item_draw(Fl_Hold_Browser self, void * item, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Hold_Browser_item_text", _wrap_Fl_Hold_Browser_item_text, METH_VARARGS, (char *)"Fl_Hold_Browser_item_text(Fl_Hold_Browser self, void * item) -> char const *"},
	 { (char *)"Fl_Hold_Browser_item_swap", _wrap_Fl_Hold_Browser_item_swap, METH_VARARGS, (char *)"Fl_Hold_Browser_item_swap(Fl_Hold_Browser self, void * a, void * b)"},
	 { (char *)"Fl_Hold_Browser_item_at", _wrap_Fl_Hold_Browser_item_at, METH_VARARGS, (char *)"Fl_Hold_Browser_item_at(Fl_Hold_Browser self, int line) -> void *"},
	 { (char *)"Fl_Hold_Browser_full_width", _wrap_Fl_Hold_Browser_full_width, METH_VARARGS, (char *)"Fl_Hold_Browser_full_width(Fl_Hold_Browser self) -> int"},
	 { (char *)"Fl_Hold_Browser_full_height", _wrap_Fl_Hold_Browser_full_height, METH_VARARGS, (char *)"Fl_Hold_Browser_full_height(Fl_Hold_Browser self) -> int"},
	 { (char *)"Fl_Hold_Browser_incr_height", _wrap_Fl_Hold_Browser_incr_height, METH_VARARGS, (char *)"Fl_Hold_Browser_incr_height(Fl_Hold_Browser self) -> int"},
	 { (char *)"Fl_Hold_Browser_item_select", _wrap_Fl_Hold_Browser_item_select, METH_VARARGS, (char *)"Fl_Hold_Browser_item_select(Fl_Hold_Browser self, void * item, int val)"},
	 { (char *)"Fl_Hold_Browser_item_selected", _wrap_Fl_Hold_Browser_item_selected, METH_VARARGS, (char *)"Fl_Hold_Browser_item_selected(Fl_Hold_Browser self, void * item) -> int"},
	 { (char *)"Fl_Hold_Browser_swigregister", Fl_Hold_Browser_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Hor_Fill_Slider", _wrap_new_Fl_Hor_Fill_Slider, METH_VARARGS, (char *)"new_Fl_Hor_Fill_Slider(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hor_Fill_Slider"},
	 { (char *)"delete_Fl_Hor_Fill_Slider", _wrap_delete_Fl_Hor_Fill_Slider, METH_VARARGS, (char *)"delete_Fl_Hor_Fill_Slider(Fl_Hor_Fill_Slider self)"},
	 { (char *)"disown_Fl_Hor_Fill_Slider", _wrap_disown_Fl_Hor_Fill_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Hor_Fill_Slider_draw", _wrap_Fl_Hor_Fill_Slider_draw, METH_VARARGS, (char *)"Fl_Hor_Fill_Slider_draw(Fl_Hor_Fill_Slider self)"},
	 { (char *)"Fl_Hor_Fill_Slider_swigregister", Fl_Hor_Fill_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Hor_Nice_Slider", _wrap_new_Fl_Hor_Nice_Slider, METH_VARARGS, (char *)"new_Fl_Hor_Nice_Slider(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hor_Nice_Slider"},
	 { (char *)"delete_Fl_Hor_Nice_Slider", _wrap_delete_Fl_Hor_Nice_Slider, METH_VARARGS, (char *)"delete_Fl_Hor_Nice_Slider(Fl_Hor_Nice_Slider self)"},
	 { (char *)"disown_Fl_Hor_Nice_Slider", _wrap_disown_Fl_Hor_Nice_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Hor_Nice_Slider_draw", _wrap_Fl_Hor_Nice_Slider_draw, METH_VARARGS, (char *)"Fl_Hor_Nice_Slider_draw(Fl_Hor_Nice_Slider self)"},
	 { (char *)"Fl_Hor_Nice_Slider_swigregister", Fl_Hor_Nice_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Hor_Slider", _wrap_new_Fl_Hor_Slider, METH_VARARGS, (char *)"new_Fl_Hor_Slider(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Hor_Slider"},
	 { (char *)"delete_Fl_Hor_Slider", _wrap_delete_Fl_Hor_Slider, METH_VARARGS, (char *)"delete_Fl_Hor_Slider(Fl_Hor_Slider self)"},
	 { (char *)"disown_Fl_Hor_Slider", _wrap_disown_Fl_Hor_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Hor_Slider_draw", _wrap_Fl_Hor_Slider_draw, METH_VARARGS, (char *)"Fl_Hor_Slider_draw(Fl_Hor_Slider self)"},
	 { (char *)"Fl_Hor_Slider_swigregister", Fl_Hor_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Value_Slider_draw", _wrap_Fl_Value_Slider_draw, METH_VARARGS, (char *)"Fl_Value_Slider_draw(Fl_Value_Slider self)"},
	 { (char *)"Fl_Value_Slider_handle", _wrap_Fl_Value_Slider_handle, METH_VARARGS, (char *)"Fl_Value_Slider_handle(Fl_Value_Slider self, int arg0) -> int"},
	 { (char *)"new_Fl_Value_Slider", _wrap_new_Fl_Value_Slider, METH_VARARGS, (char *)"new_Fl_Value_Slider(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Slider"},
	 { (char *)"Fl_Value_Slider_textfont", _wrap_Fl_Value_Slider_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Value_Slider_textfont(Fl_Value_Slider self, Fl_Font s)\n"
		""},
	 { (char *)"Fl_Value_Slider_textsize", _wrap_Fl_Value_Slider_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Value_Slider_textsize(Fl_Value_Slider self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Value_Slider_textcolor", _wrap_Fl_Value_Slider_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Value_Slider_textcolor(Fl_Value_Slider self, Fl_Color s)\n"
		""},
	 { (char *)"delete_Fl_Value_Slider", _wrap_delete_Fl_Value_Slider, METH_VARARGS, (char *)"delete_Fl_Value_Slider(Fl_Value_Slider self)"},
	 { (char *)"disown_Fl_Value_Slider", _wrap_disown_Fl_Value_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Value_Slider_swigregister", Fl_Value_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Hor_Value_Slider", _wrap_new_Fl_Hor_Value_Slider, METH_VARARGS, (char *)"new_Fl_Hor_Value_Slider(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Hor_Value_Slider"},
	 { (char *)"delete_Fl_Hor_Value_Slider", _wrap_delete_Fl_Hor_Value_Slider, METH_VARARGS, (char *)"delete_Fl_Hor_Value_Slider(Fl_Hor_Value_Slider self)"},
	 { (char *)"disown_Fl_Hor_Value_Slider", _wrap_disown_Fl_Hor_Value_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Hor_Value_Slider_draw", _wrap_Fl_Hor_Value_Slider_draw, METH_VARARGS, (char *)"Fl_Hor_Value_Slider_draw(Fl_Hor_Value_Slider self)"},
	 { (char *)"Fl_Hor_Value_Slider_swigregister", Fl_Hor_Value_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Int_Input", _wrap_new_Fl_Int_Input, METH_VARARGS, (char *)"new_Fl_Int_Input(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Int_Input"},
	 { (char *)"delete_Fl_Int_Input", _wrap_delete_Fl_Int_Input, METH_VARARGS, (char *)"delete_Fl_Int_Input(Fl_Int_Input self)"},
	 { (char *)"disown_Fl_Int_Input", _wrap_disown_Fl_Int_Input, METH_VARARGS, NULL},
	 { (char *)"Fl_Int_Input_draw", _wrap_Fl_Int_Input_draw, METH_VARARGS, (char *)"Fl_Int_Input_draw(Fl_Int_Input self)"},
	 { (char *)"Fl_Int_Input_swigregister", Fl_Int_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Input_Choice", _wrap_new_Fl_Input_Choice, METH_VARARGS, (char *)"new_Fl_Input_Choice(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Input_Choice"},
	 { (char *)"Fl_Input_Choice_add", _wrap_Fl_Input_Choice_add, METH_VARARGS, (char *)"Fl_Input_Choice_add(Fl_Input_Choice self, char const * s)"},
	 { (char *)"Fl_Input_Choice_changed", _wrap_Fl_Input_Choice_changed, METH_VARARGS, (char *)"Fl_Input_Choice_changed(Fl_Input_Choice self) -> int"},
	 { (char *)"Fl_Input_Choice_clear_changed", _wrap_Fl_Input_Choice_clear_changed, METH_VARARGS, (char *)"Fl_Input_Choice_clear_changed(Fl_Input_Choice self)"},
	 { (char *)"Fl_Input_Choice_set_changed", _wrap_Fl_Input_Choice_set_changed, METH_VARARGS, (char *)"Fl_Input_Choice_set_changed(Fl_Input_Choice self)"},
	 { (char *)"Fl_Input_Choice_clear", _wrap_Fl_Input_Choice_clear, METH_VARARGS, (char *)"Fl_Input_Choice_clear(Fl_Input_Choice self)"},
	 { (char *)"Fl_Input_Choice_down_box", _wrap_Fl_Input_Choice_down_box, METH_VARARGS, (char *)"\n"
		"down_box() -> Fl_Boxtype\n"
		"Fl_Input_Choice_down_box(Fl_Input_Choice self, Fl_Boxtype b)\n"
		""},
	 { (char *)"Fl_Input_Choice_menu", _wrap_Fl_Input_Choice_menu, METH_VARARGS, (char *)"\n"
		"menu() -> Fl_Menu_Item\n"
		"Fl_Input_Choice_menu(Fl_Input_Choice self, Fl_Menu_Item m)\n"
		""},
	 { (char *)"Fl_Input_Choice_resize", _wrap_Fl_Input_Choice_resize, METH_VARARGS, (char *)"Fl_Input_Choice_resize(Fl_Input_Choice self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Input_Choice_textcolor", _wrap_Fl_Input_Choice_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Input_Choice_textcolor(Fl_Input_Choice self, Fl_Color c)\n"
		""},
	 { (char *)"Fl_Input_Choice_textfont", _wrap_Fl_Input_Choice_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Input_Choice_textfont(Fl_Input_Choice self, Fl_Font f)\n"
		""},
	 { (char *)"Fl_Input_Choice_textsize", _wrap_Fl_Input_Choice_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Input_Choice_textsize(Fl_Input_Choice self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Input_Choice_value", _wrap_Fl_Input_Choice_value, METH_VARARGS, (char *)"\n"
		"value() -> char const\n"
		"value(char const * val)\n"
		"Fl_Input_Choice_value(Fl_Input_Choice self, int val)\n"
		""},
	 { (char *)"Fl_Input_Choice_menubutton", _wrap_Fl_Input_Choice_menubutton, METH_VARARGS, (char *)"Fl_Input_Choice_menubutton(Fl_Input_Choice self) -> Fl_Menu_Button"},
	 { (char *)"Fl_Input_Choice_input", _wrap_Fl_Input_Choice_input, METH_VARARGS, (char *)"Fl_Input_Choice_input(Fl_Input_Choice self) -> Fl_Input"},
	 { (char *)"delete_Fl_Input_Choice", _wrap_delete_Fl_Input_Choice, METH_VARARGS, (char *)"delete_Fl_Input_Choice(Fl_Input_Choice self)"},
	 { (char *)"disown_Fl_Input_Choice", _wrap_disown_Fl_Input_Choice, METH_VARARGS, NULL},
	 { (char *)"Fl_Input_Choice_draw", _wrap_Fl_Input_Choice_draw, METH_VARARGS, (char *)"Fl_Input_Choice_draw(Fl_Input_Choice self)"},
	 { (char *)"Fl_Input_Choice_swigregister", Fl_Input_Choice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_JPEG_Image", _wrap_new_Fl_JPEG_Image, METH_VARARGS, (char *)"\n"
		"Fl_JPEG_Image(char const * filename)\n"
		"new_Fl_JPEG_Image(PyObject * self, char const * name, unsigned char const * data) -> Fl_JPEG_Image\n"
		""},
	 { (char *)"delete_Fl_JPEG_Image", _wrap_delete_Fl_JPEG_Image, METH_VARARGS, (char *)"delete_Fl_JPEG_Image(Fl_JPEG_Image self)"},
	 { (char *)"disown_Fl_JPEG_Image", _wrap_disown_Fl_JPEG_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_JPEG_Image_swigregister", Fl_JPEG_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Line_Dial", _wrap_new_Fl_Line_Dial, METH_VARARGS, (char *)"new_Fl_Line_Dial(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Line_Dial"},
	 { (char *)"delete_Fl_Line_Dial", _wrap_delete_Fl_Line_Dial, METH_VARARGS, (char *)"delete_Fl_Line_Dial(Fl_Line_Dial self)"},
	 { (char *)"disown_Fl_Line_Dial", _wrap_disown_Fl_Line_Dial, METH_VARARGS, NULL},
	 { (char *)"Fl_Line_Dial_draw", _wrap_Fl_Line_Dial_draw, METH_VARARGS, (char *)"Fl_Line_Dial_draw(Fl_Line_Dial self)"},
	 { (char *)"Fl_Line_Dial_swigregister", Fl_Line_Dial_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu_Bar_draw", _wrap_Fl_Menu_Bar_draw, METH_VARARGS, (char *)"Fl_Menu_Bar_draw(Fl_Menu_Bar self)"},
	 { (char *)"Fl_Menu_Bar_handle", _wrap_Fl_Menu_Bar_handle, METH_VARARGS, (char *)"Fl_Menu_Bar_handle(Fl_Menu_Bar self, int arg0) -> int"},
	 { (char *)"new_Fl_Menu_Bar", _wrap_new_Fl_Menu_Bar, METH_VARARGS, (char *)"new_Fl_Menu_Bar(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Menu_Bar"},
	 { (char *)"delete_Fl_Menu_Bar", _wrap_delete_Fl_Menu_Bar, METH_VARARGS, (char *)"delete_Fl_Menu_Bar(Fl_Menu_Bar self)"},
	 { (char *)"disown_Fl_Menu_Bar", _wrap_disown_Fl_Menu_Bar, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu_Bar_swigregister", Fl_Menu_Bar_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu_Button_draw", _wrap_Fl_Menu_Button_draw, METH_VARARGS, (char *)"Fl_Menu_Button_draw(Fl_Menu_Button self)"},
	 { (char *)"Fl_Menu_Button_handle", _wrap_Fl_Menu_Button_handle, METH_VARARGS, (char *)"Fl_Menu_Button_handle(Fl_Menu_Button self, int arg0) -> int"},
	 { (char *)"Fl_Menu_Button_popup", _wrap_Fl_Menu_Button_popup, METH_VARARGS, (char *)"Fl_Menu_Button_popup(Fl_Menu_Button self) -> Fl_Menu_Item"},
	 { (char *)"new_Fl_Menu_Button", _wrap_new_Fl_Menu_Button, METH_VARARGS, (char *)"new_Fl_Menu_Button(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Menu_Button"},
	 { (char *)"delete_Fl_Menu_Button", _wrap_delete_Fl_Menu_Button, METH_VARARGS, (char *)"delete_Fl_Menu_Button(Fl_Menu_Button self)"},
	 { (char *)"disown_Fl_Menu_Button", _wrap_disown_Fl_Menu_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu_Button_swigregister", Fl_Menu_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu_Item_next", _wrap_Fl_Menu_Item_next, METH_VARARGS, (char *)"\n"
		"next(int arg2=1) -> Fl_Menu_Item\n"
		"Fl_Menu_Item_next(Fl_Menu_Item self, int i=1) -> Fl_Menu_Item\n"
		""},
	 { (char *)"Fl_Menu_Item_first", _wrap_Fl_Menu_Item_first, METH_VARARGS, (char *)"\n"
		"first() -> Fl_Menu_Item\n"
		"Fl_Menu_Item_first(Fl_Menu_Item self) -> Fl_Menu_Item\n"
		""},
	 { (char *)"Fl_Menu_Item_label", _wrap_Fl_Menu_Item_label, METH_VARARGS, (char *)"\n"
		"label() -> char const\n"
		"label(char const * a)\n"
		"Fl_Menu_Item_label(Fl_Menu_Item self, Fl_Labeltype a, char const * b)\n"
		""},
	 { (char *)"Fl_Menu_Item_labeltype", _wrap_Fl_Menu_Item_labeltype, METH_VARARGS, (char *)"\n"
		"labeltype() -> Fl_Labeltype\n"
		"Fl_Menu_Item_labeltype(Fl_Menu_Item self, Fl_Labeltype a)\n"
		""},
	 { (char *)"Fl_Menu_Item_labelcolor", _wrap_Fl_Menu_Item_labelcolor, METH_VARARGS, (char *)"\n"
		"labelcolor() -> Fl_Color\n"
		"Fl_Menu_Item_labelcolor(Fl_Menu_Item self, Fl_Color a)\n"
		""},
	 { (char *)"Fl_Menu_Item_labelfont", _wrap_Fl_Menu_Item_labelfont, METH_VARARGS, (char *)"\n"
		"labelfont() -> Fl_Font\n"
		"Fl_Menu_Item_labelfont(Fl_Menu_Item self, Fl_Font a)\n"
		""},
	 { (char *)"Fl_Menu_Item_labelsize", _wrap_Fl_Menu_Item_labelsize, METH_VARARGS, (char *)"\n"
		"labelsize() -> Fl_Fontsize\n"
		"Fl_Menu_Item_labelsize(Fl_Menu_Item self, Fl_Fontsize a)\n"
		""},
	 { (char *)"Fl_Menu_Item_argument", _wrap_Fl_Menu_Item_argument, METH_VARARGS, (char *)"\n"
		"argument() -> long\n"
		"Fl_Menu_Item_argument(Fl_Menu_Item self, long v)\n"
		""},
	 { (char *)"Fl_Menu_Item_shortcut", _wrap_Fl_Menu_Item_shortcut, METH_VARARGS, (char *)"\n"
		"shortcut() -> int\n"
		"Fl_Menu_Item_shortcut(Fl_Menu_Item self, int s)\n"
		""},
	 { (char *)"Fl_Menu_Item_submenu", _wrap_Fl_Menu_Item_submenu, METH_VARARGS, (char *)"Fl_Menu_Item_submenu(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_checkbox", _wrap_Fl_Menu_Item_checkbox, METH_VARARGS, (char *)"Fl_Menu_Item_checkbox(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_radio", _wrap_Fl_Menu_Item_radio, METH_VARARGS, (char *)"Fl_Menu_Item_radio(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_value", _wrap_Fl_Menu_Item_value, METH_VARARGS, (char *)"Fl_Menu_Item_value(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_set", _wrap_Fl_Menu_Item_set, METH_VARARGS, (char *)"Fl_Menu_Item_set(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_clear", _wrap_Fl_Menu_Item_clear, METH_VARARGS, (char *)"Fl_Menu_Item_clear(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_setonly", _wrap_Fl_Menu_Item_setonly, METH_VARARGS, (char *)"Fl_Menu_Item_setonly(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_visible", _wrap_Fl_Menu_Item_visible, METH_VARARGS, (char *)"Fl_Menu_Item_visible(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_show", _wrap_Fl_Menu_Item_show, METH_VARARGS, (char *)"Fl_Menu_Item_show(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_hide", _wrap_Fl_Menu_Item_hide, METH_VARARGS, (char *)"Fl_Menu_Item_hide(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_active", _wrap_Fl_Menu_Item_active, METH_VARARGS, (char *)"Fl_Menu_Item_active(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_activate", _wrap_Fl_Menu_Item_activate, METH_VARARGS, (char *)"Fl_Menu_Item_activate(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_deactivate", _wrap_Fl_Menu_Item_deactivate, METH_VARARGS, (char *)"Fl_Menu_Item_deactivate(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_activevisible", _wrap_Fl_Menu_Item_activevisible, METH_VARARGS, (char *)"Fl_Menu_Item_activevisible(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_image", _wrap_Fl_Menu_Item_image, METH_VARARGS, (char *)"Fl_Menu_Item_image(Fl_Menu_Item self, Fl_Image a)"},
	 { (char *)"Fl_Menu_Item_measure", _wrap_Fl_Menu_Item_measure, METH_VARARGS, (char *)"Fl_Menu_Item_measure(Fl_Menu_Item self, int * h, Fl_Menu_ arg3) -> int"},
	 { (char *)"Fl_Menu_Item_draw", _wrap_Fl_Menu_Item_draw, METH_VARARGS, (char *)"Fl_Menu_Item_draw(Fl_Menu_Item self, int x, int y, int w, int h, Fl_Menu_ arg6, int t=0)"},
	 { (char *)"Fl_Menu_Item_popup", _wrap_Fl_Menu_Item_popup, METH_VARARGS, (char *)"\n"
		"Fl_Menu_Item_popup(Fl_Menu_Item self, int X, int Y, char const * title=None, Fl_Menu_Item picked=None, \n"
		"    Fl_Menu_ arg6=None) -> Fl_Menu_Item\n"
		""},
	 { (char *)"Fl_Menu_Item_pulldown", _wrap_Fl_Menu_Item_pulldown, METH_VARARGS, (char *)"\n"
		"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, \n"
		"    Fl_Menu_Item title=None, int menubar=0) -> Fl_Menu_Item\n"
		""},
	 { (char *)"Fl_Menu_Item_test_shortcut", _wrap_Fl_Menu_Item_test_shortcut, METH_VARARGS, (char *)"Fl_Menu_Item_test_shortcut(Fl_Menu_Item self) -> Fl_Menu_Item"},
	 { (char *)"Fl_Menu_Item_find_shortcut", _wrap_Fl_Menu_Item_find_shortcut, METH_VARARGS, (char *)"Fl_Menu_Item_find_shortcut(Fl_Menu_Item self, int * ip=None, bool const require_alt=False) -> Fl_Menu_Item"},
	 { (char *)"Fl_Menu_Item_do_callback", _wrap_Fl_Menu_Item_do_callback, METH_VARARGS, (char *)"\n"
		"do_callback(Fl_Widget o)\n"
		"do_callback(Fl_Widget o, void * arg)\n"
		"Fl_Menu_Item_do_callback(Fl_Menu_Item self, Fl_Widget o, long arg)\n"
		""},
	 { (char *)"Fl_Menu_Item_checked", _wrap_Fl_Menu_Item_checked, METH_VARARGS, (char *)"Fl_Menu_Item_checked(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_check", _wrap_Fl_Menu_Item_check, METH_VARARGS, (char *)"Fl_Menu_Item_check(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_uncheck", _wrap_Fl_Menu_Item_uncheck, METH_VARARGS, (char *)"Fl_Menu_Item_uncheck(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_insert", _wrap_Fl_Menu_Item_insert, METH_VARARGS, (char *)"\n"
		"Fl_Menu_Item_insert(Fl_Menu_Item self, int arg2, char const * arg3, int arg4, Fl_Callback * arg5, void * arg6=None, \n"
		"    int arg7=0) -> int\n"
		""},
	 { (char *)"Fl_Menu_Item_add", _wrap_Fl_Menu_Item_add, METH_VARARGS, (char *)"\n"
		"add(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, \n"
		"    int e=0) -> int\n"
		""},
	 { (char *)"Fl_Menu_Item_size", _wrap_Fl_Menu_Item_size, METH_VARARGS, (char *)"Fl_Menu_Item_size(Fl_Menu_Item self) -> int"},
	 { (char *)"Fl_Menu_Item_callback", _wrap_Fl_Menu_Item_callback, METH_VARARGS, (char *)"\n"
		"callback(Fl_Callback * c, void * p)\n"
		"callback(Fl_Callback * c)\n"
		"callback(Fl_Callback0 * c)\n"
		"callback(Fl_Callback1 * c, long p=0)\n"
		"Fl_Menu_Item_callback(Fl_Menu_Item self) -> PyObject *\n"
		""},
	 { (char *)"Fl_Menu_Item_user_data", _wrap_Fl_Menu_Item_user_data, METH_VARARGS, (char *)"\n"
		"user_data()\n"
		"user_data(void * v)\n"
		"Fl_Menu_Item_user_data(Fl_Menu_Item self) -> PyObject *\n"
		""},
	 { (char *)"new_Fl_Menu_Item", _wrap_new_Fl_Menu_Item, METH_VARARGS, (char *)"new_Fl_Menu_Item() -> Fl_Menu_Item"},
	 { (char *)"delete_Fl_Menu_Item", _wrap_delete_Fl_Menu_Item, METH_VARARGS, (char *)"delete_Fl_Menu_Item(Fl_Menu_Item self)"},
	 { (char *)"Fl_Menu_Item_swigregister", Fl_Menu_Item_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Single_Window_flush", _wrap_Fl_Single_Window_flush, METH_VARARGS, (char *)"Fl_Single_Window_flush(Fl_Single_Window self)"},
	 { (char *)"new_Fl_Single_Window", _wrap_new_Fl_Single_Window, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Single_Window_show", _wrap_Fl_Single_Window_show, METH_VARARGS, (char *)"Fl_Single_Window_show(Fl_Single_Window self, PyObject * count=None, PyObject * data=None)"},
	 { (char *)"delete_Fl_Single_Window", _wrap_delete_Fl_Single_Window, METH_VARARGS, (char *)"delete_Fl_Single_Window(Fl_Single_Window self)"},
	 { (char *)"disown_Fl_Single_Window", _wrap_disown_Fl_Single_Window, METH_VARARGS, NULL},
	 { (char *)"Fl_Single_Window_draw", _wrap_Fl_Single_Window_draw, METH_VARARGS, (char *)"Fl_Single_Window_draw(Fl_Single_Window self)"},
	 { (char *)"Fl_Single_Window_swigregister", Fl_Single_Window_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu_Window_erase", _wrap_Fl_Menu_Window_erase, METH_VARARGS, (char *)"Fl_Menu_Window_erase(Fl_Menu_Window self)"},
	 { (char *)"Fl_Menu_Window_flush", _wrap_Fl_Menu_Window_flush, METH_VARARGS, (char *)"Fl_Menu_Window_flush(Fl_Menu_Window self)"},
	 { (char *)"Fl_Menu_Window_hide", _wrap_Fl_Menu_Window_hide, METH_VARARGS, (char *)"Fl_Menu_Window_hide(Fl_Menu_Window self)"},
	 { (char *)"Fl_Menu_Window_overlay", _wrap_Fl_Menu_Window_overlay, METH_VARARGS, (char *)"Fl_Menu_Window_overlay(Fl_Menu_Window self) -> unsigned int"},
	 { (char *)"Fl_Menu_Window_set_overlay", _wrap_Fl_Menu_Window_set_overlay, METH_VARARGS, (char *)"Fl_Menu_Window_set_overlay(Fl_Menu_Window self)"},
	 { (char *)"Fl_Menu_Window_clear_overlay", _wrap_Fl_Menu_Window_clear_overlay, METH_VARARGS, (char *)"Fl_Menu_Window_clear_overlay(Fl_Menu_Window self)"},
	 { (char *)"delete_Fl_Menu_Window", _wrap_delete_Fl_Menu_Window, METH_VARARGS, (char *)"delete_Fl_Menu_Window(Fl_Menu_Window self)"},
	 { (char *)"new_Fl_Menu_Window", _wrap_new_Fl_Menu_Window, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"disown_Fl_Menu_Window", _wrap_disown_Fl_Menu_Window, METH_VARARGS, NULL},
	 { (char *)"Fl_Menu_Window_draw", _wrap_Fl_Menu_Window_draw, METH_VARARGS, (char *)"Fl_Menu_Window_draw(Fl_Menu_Window self)"},
	 { (char *)"Fl_Menu_Window_swigregister", Fl_Menu_Window_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Multiline_Input", _wrap_new_Fl_Multiline_Input, METH_VARARGS, (char *)"new_Fl_Multiline_Input(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Multiline_Input"},
	 { (char *)"delete_Fl_Multiline_Input", _wrap_delete_Fl_Multiline_Input, METH_VARARGS, (char *)"delete_Fl_Multiline_Input(Fl_Multiline_Input self)"},
	 { (char *)"disown_Fl_Multiline_Input", _wrap_disown_Fl_Multiline_Input, METH_VARARGS, NULL},
	 { (char *)"Fl_Multiline_Input_draw", _wrap_Fl_Multiline_Input_draw, METH_VARARGS, (char *)"Fl_Multiline_Input_draw(Fl_Multiline_Input self)"},
	 { (char *)"Fl_Multiline_Input_swigregister", Fl_Multiline_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Output", _wrap_new_Fl_Output, METH_VARARGS, (char *)"new_Fl_Output(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Output"},
	 { (char *)"delete_Fl_Output", _wrap_delete_Fl_Output, METH_VARARGS, (char *)"delete_Fl_Output(Fl_Output self)"},
	 { (char *)"disown_Fl_Output", _wrap_disown_Fl_Output, METH_VARARGS, NULL},
	 { (char *)"Fl_Output_draw", _wrap_Fl_Output_draw, METH_VARARGS, (char *)"Fl_Output_draw(Fl_Output self)"},
	 { (char *)"Fl_Output_swigregister", Fl_Output_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Multiline_Output", _wrap_new_Fl_Multiline_Output, METH_VARARGS, (char *)"new_Fl_Multiline_Output(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Multiline_Output"},
	 { (char *)"delete_Fl_Multiline_Output", _wrap_delete_Fl_Multiline_Output, METH_VARARGS, (char *)"delete_Fl_Multiline_Output(Fl_Multiline_Output self)"},
	 { (char *)"disown_Fl_Multiline_Output", _wrap_disown_Fl_Multiline_Output, METH_VARARGS, NULL},
	 { (char *)"Fl_Multiline_Output_draw", _wrap_Fl_Multiline_Output_draw, METH_VARARGS, (char *)"Fl_Multiline_Output_draw(Fl_Multiline_Output self)"},
	 { (char *)"Fl_Multiline_Output_swigregister", Fl_Multiline_Output_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Multi_Browser", _wrap_new_Fl_Multi_Browser, METH_VARARGS, (char *)"new_Fl_Multi_Browser(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Multi_Browser"},
	 { (char *)"delete_Fl_Multi_Browser", _wrap_delete_Fl_Multi_Browser, METH_VARARGS, (char *)"delete_Fl_Multi_Browser(Fl_Multi_Browser self)"},
	 { (char *)"disown_Fl_Multi_Browser", _wrap_disown_Fl_Multi_Browser, METH_VARARGS, NULL},
	 { (char *)"Fl_Multi_Browser_draw", _wrap_Fl_Multi_Browser_draw, METH_VARARGS, (char *)"Fl_Multi_Browser_draw(Fl_Multi_Browser self)"},
	 { (char *)"Fl_Multi_Browser_item_first", _wrap_Fl_Multi_Browser_item_first, METH_VARARGS, (char *)"Fl_Multi_Browser_item_first(Fl_Multi_Browser self) -> void *"},
	 { (char *)"Fl_Multi_Browser_item_next", _wrap_Fl_Multi_Browser_item_next, METH_VARARGS, (char *)"Fl_Multi_Browser_item_next(Fl_Multi_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Multi_Browser_item_prev", _wrap_Fl_Multi_Browser_item_prev, METH_VARARGS, (char *)"Fl_Multi_Browser_item_prev(Fl_Multi_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Multi_Browser_item_last", _wrap_Fl_Multi_Browser_item_last, METH_VARARGS, (char *)"Fl_Multi_Browser_item_last(Fl_Multi_Browser self) -> void *"},
	 { (char *)"Fl_Multi_Browser_item_height", _wrap_Fl_Multi_Browser_item_height, METH_VARARGS, (char *)"Fl_Multi_Browser_item_height(Fl_Multi_Browser self, void * item) -> int"},
	 { (char *)"Fl_Multi_Browser_item_width", _wrap_Fl_Multi_Browser_item_width, METH_VARARGS, (char *)"Fl_Multi_Browser_item_width(Fl_Multi_Browser self, void * item) -> int"},
	 { (char *)"Fl_Multi_Browser_item_quick_height", _wrap_Fl_Multi_Browser_item_quick_height, METH_VARARGS, (char *)"Fl_Multi_Browser_item_quick_height(Fl_Multi_Browser self, void * item) -> int"},
	 { (char *)"Fl_Multi_Browser_item_draw", _wrap_Fl_Multi_Browser_item_draw, METH_VARARGS, (char *)"Fl_Multi_Browser_item_draw(Fl_Multi_Browser self, void * item, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Multi_Browser_item_text", _wrap_Fl_Multi_Browser_item_text, METH_VARARGS, (char *)"Fl_Multi_Browser_item_text(Fl_Multi_Browser self, void * item) -> char const *"},
	 { (char *)"Fl_Multi_Browser_item_swap", _wrap_Fl_Multi_Browser_item_swap, METH_VARARGS, (char *)"Fl_Multi_Browser_item_swap(Fl_Multi_Browser self, void * a, void * b)"},
	 { (char *)"Fl_Multi_Browser_item_at", _wrap_Fl_Multi_Browser_item_at, METH_VARARGS, (char *)"Fl_Multi_Browser_item_at(Fl_Multi_Browser self, int line) -> void *"},
	 { (char *)"Fl_Multi_Browser_full_width", _wrap_Fl_Multi_Browser_full_width, METH_VARARGS, (char *)"Fl_Multi_Browser_full_width(Fl_Multi_Browser self) -> int"},
	 { (char *)"Fl_Multi_Browser_full_height", _wrap_Fl_Multi_Browser_full_height, METH_VARARGS, (char *)"Fl_Multi_Browser_full_height(Fl_Multi_Browser self) -> int"},
	 { (char *)"Fl_Multi_Browser_incr_height", _wrap_Fl_Multi_Browser_incr_height, METH_VARARGS, (char *)"Fl_Multi_Browser_incr_height(Fl_Multi_Browser self) -> int"},
	 { (char *)"Fl_Multi_Browser_item_select", _wrap_Fl_Multi_Browser_item_select, METH_VARARGS, (char *)"Fl_Multi_Browser_item_select(Fl_Multi_Browser self, void * item, int val)"},
	 { (char *)"Fl_Multi_Browser_item_selected", _wrap_Fl_Multi_Browser_item_selected, METH_VARARGS, (char *)"Fl_Multi_Browser_item_selected(Fl_Multi_Browser self, void * item) -> int"},
	 { (char *)"Fl_Multi_Browser_swigregister", Fl_Multi_Browser_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Multi_Label_label", _wrap_Fl_Multi_Label_label, METH_VARARGS, (char *)"\n"
		"label(Fl_Widget arg2)\n"
		"Fl_Multi_Label_label(Fl_Multi_Label self, Fl_Menu_Item arg2)\n"
		""},
	 { (char *)"new_Fl_Multi_Label", _wrap_new_Fl_Multi_Label, METH_VARARGS, (char *)"new_Fl_Multi_Label() -> Fl_Multi_Label"},
	 { (char *)"delete_Fl_Multi_Label", _wrap_delete_Fl_Multi_Label, METH_VARARGS, (char *)"delete_Fl_Multi_Label(Fl_Multi_Label self)"},
	 { (char *)"Fl_Multi_Label_swigregister", Fl_Multi_Label_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Nice_Slider", _wrap_new_Fl_Nice_Slider, METH_VARARGS, (char *)"new_Fl_Nice_Slider(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Nice_Slider"},
	 { (char *)"delete_Fl_Nice_Slider", _wrap_delete_Fl_Nice_Slider, METH_VARARGS, (char *)"delete_Fl_Nice_Slider(Fl_Nice_Slider self)"},
	 { (char *)"disown_Fl_Nice_Slider", _wrap_disown_Fl_Nice_Slider, METH_VARARGS, NULL},
	 { (char *)"Fl_Nice_Slider_draw", _wrap_Fl_Nice_Slider_draw, METH_VARARGS, (char *)"Fl_Nice_Slider_draw(Fl_Nice_Slider self)"},
	 { (char *)"Fl_Nice_Slider_swigregister", Fl_Nice_Slider_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Overlay_Window_draw_overlay", _wrap_Fl_Overlay_Window_draw_overlay, METH_VARARGS, (char *)"Fl_Overlay_Window_draw_overlay(Fl_Overlay_Window self)"},
	 { (char *)"Fl_Overlay_Window_flush", _wrap_Fl_Overlay_Window_flush, METH_VARARGS, (char *)"Fl_Overlay_Window_flush(Fl_Overlay_Window self)"},
	 { (char *)"Fl_Overlay_Window_hide", _wrap_Fl_Overlay_Window_hide, METH_VARARGS, (char *)"Fl_Overlay_Window_hide(Fl_Overlay_Window self)"},
	 { (char *)"Fl_Overlay_Window_resize", _wrap_Fl_Overlay_Window_resize, METH_VARARGS, (char *)"Fl_Overlay_Window_resize(Fl_Overlay_Window self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"delete_Fl_Overlay_Window", _wrap_delete_Fl_Overlay_Window, METH_VARARGS, (char *)"delete_Fl_Overlay_Window(Fl_Overlay_Window self)"},
	 { (char *)"Fl_Overlay_Window_can_do_overlay", _wrap_Fl_Overlay_Window_can_do_overlay, METH_VARARGS, (char *)"Fl_Overlay_Window_can_do_overlay(Fl_Overlay_Window self) -> int"},
	 { (char *)"Fl_Overlay_Window_redraw_overlay", _wrap_Fl_Overlay_Window_redraw_overlay, METH_VARARGS, (char *)"Fl_Overlay_Window_redraw_overlay(Fl_Overlay_Window self)"},
	 { (char *)"new_Fl_Overlay_Window", _wrap_new_Fl_Overlay_Window, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Overlay_Window_show", _wrap_Fl_Overlay_Window_show, METH_VARARGS, (char *)"Fl_Overlay_Window_show(Fl_Overlay_Window self, PyObject * count=None, PyObject * data=None)"},
	 { (char *)"disown_Fl_Overlay_Window", _wrap_disown_Fl_Overlay_Window, METH_VARARGS, NULL},
	 { (char *)"Fl_Overlay_Window_draw", _wrap_Fl_Overlay_Window_draw, METH_VARARGS, (char *)"Fl_Overlay_Window_draw(Fl_Overlay_Window self)"},
	 { (char *)"Fl_Overlay_Window_swigregister", Fl_Overlay_Window_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Pack_draw", _wrap_Fl_Pack_draw, METH_VARARGS, (char *)"Fl_Pack_draw(Fl_Pack self)"},
	 { (char *)"new_Fl_Pack", _wrap_new_Fl_Pack, METH_VARARGS, (char *)"new_Fl_Pack(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Pack"},
	 { (char *)"Fl_Pack_spacing", _wrap_Fl_Pack_spacing, METH_VARARGS, (char *)"\n"
		"spacing() -> int\n"
		"Fl_Pack_spacing(Fl_Pack self, int i)\n"
		""},
	 { (char *)"Fl_Pack_horizontal", _wrap_Fl_Pack_horizontal, METH_VARARGS, (char *)"Fl_Pack_horizontal(Fl_Pack self) -> uchar"},
	 { (char *)"delete_Fl_Pack", _wrap_delete_Fl_Pack, METH_VARARGS, (char *)"delete_Fl_Pack(Fl_Pack self)"},
	 { (char *)"disown_Fl_Pack", _wrap_disown_Fl_Pack, METH_VARARGS, NULL},
	 { (char *)"Fl_Pack_swigregister", Fl_Pack_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_PNG_Image", _wrap_new_Fl_PNG_Image, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"delete_Fl_PNG_Image", _wrap_delete_Fl_PNG_Image, METH_VARARGS, (char *)"delete_Fl_PNG_Image(Fl_PNG_Image self)"},
	 { (char *)"disown_Fl_PNG_Image", _wrap_disown_Fl_PNG_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_PNG_Image_swigregister", Fl_PNG_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_PNM_Image", _wrap_new_Fl_PNM_Image, METH_VARARGS, (char *)"new_Fl_PNM_Image(PyObject * self, char const * filename) -> Fl_PNM_Image"},
	 { (char *)"delete_Fl_PNM_Image", _wrap_delete_Fl_PNM_Image, METH_VARARGS, (char *)"delete_Fl_PNM_Image(Fl_PNM_Image self)"},
	 { (char *)"disown_Fl_PNM_Image", _wrap_disown_Fl_PNM_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_PNM_Image_swigregister", Fl_PNM_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Positioner_draw", _wrap_Fl_Positioner_draw, METH_VARARGS, (char *)"Fl_Positioner_draw(Fl_Positioner self)"},
	 { (char *)"Fl_Positioner_handle", _wrap_Fl_Positioner_handle, METH_VARARGS, (char *)"Fl_Positioner_handle(Fl_Positioner self, int arg0) -> int"},
	 { (char *)"new_Fl_Positioner", _wrap_new_Fl_Positioner, METH_VARARGS, (char *)"new_Fl_Positioner(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Positioner"},
	 { (char *)"Fl_Positioner_xvalue", _wrap_Fl_Positioner_xvalue, METH_VARARGS, (char *)"\n"
		"xvalue() -> double\n"
		"Fl_Positioner_xvalue(Fl_Positioner self, double arg2) -> int\n"
		""},
	 { (char *)"Fl_Positioner_yvalue", _wrap_Fl_Positioner_yvalue, METH_VARARGS, (char *)"\n"
		"yvalue() -> double\n"
		"Fl_Positioner_yvalue(Fl_Positioner self, double arg2) -> int\n"
		""},
	 { (char *)"Fl_Positioner_value", _wrap_Fl_Positioner_value, METH_VARARGS, (char *)"Fl_Positioner_value(Fl_Positioner self, double arg2, double arg3) -> int"},
	 { (char *)"Fl_Positioner_xbounds", _wrap_Fl_Positioner_xbounds, METH_VARARGS, (char *)"Fl_Positioner_xbounds(Fl_Positioner self, double arg2, double arg3)"},
	 { (char *)"Fl_Positioner_xminimum", _wrap_Fl_Positioner_xminimum, METH_VARARGS, (char *)"\n"
		"xminimum() -> double\n"
		"Fl_Positioner_xminimum(Fl_Positioner self, double a)\n"
		""},
	 { (char *)"Fl_Positioner_xmaximum", _wrap_Fl_Positioner_xmaximum, METH_VARARGS, (char *)"\n"
		"xmaximum() -> double\n"
		"Fl_Positioner_xmaximum(Fl_Positioner self, double a)\n"
		""},
	 { (char *)"Fl_Positioner_ybounds", _wrap_Fl_Positioner_ybounds, METH_VARARGS, (char *)"Fl_Positioner_ybounds(Fl_Positioner self, double arg2, double arg3)"},
	 { (char *)"Fl_Positioner_yminimum", _wrap_Fl_Positioner_yminimum, METH_VARARGS, (char *)"\n"
		"yminimum() -> double\n"
		"Fl_Positioner_yminimum(Fl_Positioner self, double a)\n"
		""},
	 { (char *)"Fl_Positioner_ymaximum", _wrap_Fl_Positioner_ymaximum, METH_VARARGS, (char *)"\n"
		"ymaximum() -> double\n"
		"Fl_Positioner_ymaximum(Fl_Positioner self, double a)\n"
		""},
	 { (char *)"Fl_Positioner_xstep", _wrap_Fl_Positioner_xstep, METH_VARARGS, (char *)"Fl_Positioner_xstep(Fl_Positioner self, double a)"},
	 { (char *)"Fl_Positioner_ystep", _wrap_Fl_Positioner_ystep, METH_VARARGS, (char *)"Fl_Positioner_ystep(Fl_Positioner self, double a)"},
	 { (char *)"delete_Fl_Positioner", _wrap_delete_Fl_Positioner, METH_VARARGS, (char *)"delete_Fl_Positioner(Fl_Positioner self)"},
	 { (char *)"disown_Fl_Positioner", _wrap_disown_Fl_Positioner, METH_VARARGS, NULL},
	 { (char *)"Fl_Positioner_swigregister", Fl_Positioner_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Preferences", _wrap_new_Fl_Preferences, METH_VARARGS, (char *)"\n"
		"Fl_Preferences(Fl_Preferences::Root root, char const * vendor, char const * application)\n"
		"Fl_Preferences(char const * path, char const * vendor, char const * application)\n"
		"new_Fl_Preferences(Fl_Preferences arg1, char const * group) -> Fl_Preferences\n"
		""},
	 { (char *)"delete_Fl_Preferences", _wrap_delete_Fl_Preferences, METH_VARARGS, (char *)"delete_Fl_Preferences(Fl_Preferences self)"},
	 { (char *)"Fl_Preferences_groups", _wrap_Fl_Preferences_groups, METH_VARARGS, (char *)"Fl_Preferences_groups(Fl_Preferences self) -> int"},
	 { (char *)"Fl_Preferences_group", _wrap_Fl_Preferences_group, METH_VARARGS, (char *)"Fl_Preferences_group(Fl_Preferences self, int arg2) -> char const *"},
	 { (char *)"Fl_Preferences_groupExists", _wrap_Fl_Preferences_groupExists, METH_VARARGS, (char *)"Fl_Preferences_groupExists(Fl_Preferences self, char const * group) -> char"},
	 { (char *)"Fl_Preferences_deleteGroup", _wrap_Fl_Preferences_deleteGroup, METH_VARARGS, (char *)"Fl_Preferences_deleteGroup(Fl_Preferences self, char const * group) -> char"},
	 { (char *)"Fl_Preferences_entries", _wrap_Fl_Preferences_entries, METH_VARARGS, (char *)"Fl_Preferences_entries(Fl_Preferences self) -> int"},
	 { (char *)"Fl_Preferences_entry", _wrap_Fl_Preferences_entry, METH_VARARGS, (char *)"Fl_Preferences_entry(Fl_Preferences self, int arg2) -> char const *"},
	 { (char *)"Fl_Preferences_entryExists", _wrap_Fl_Preferences_entryExists, METH_VARARGS, (char *)"Fl_Preferences_entryExists(Fl_Preferences self, char const * entry) -> char"},
	 { (char *)"Fl_Preferences_deleteEntry", _wrap_Fl_Preferences_deleteEntry, METH_VARARGS, (char *)"Fl_Preferences_deleteEntry(Fl_Preferences self, char const * entry) -> char"},
	 { (char *)"Fl_Preferences_set", _wrap_Fl_Preferences_set, METH_VARARGS, (char *)"\n"
		"set(char const * entry, int value) -> char\n"
		"set(char const * entry, float value, int precision) -> char\n"
		"set(char const * entry, double value) -> char\n"
		"set(char const * entry, double value, int precision) -> char\n"
		"set(char const * entry, char const * cvalue) -> char\n"
		"Fl_Preferences_set(Fl_Preferences self, char const * entry, void const * cvalue, int size) -> char\n"
		""},
	 { (char *)"Fl_Preferences_get", _wrap_Fl_Preferences_get, METH_VARARGS, (char *)"\n"
		"get(char const * entry, int defaultValue) -> char\n"
		"get(char const * entry, float defaultValue) -> char\n"
		"get(char const * entry, double defaultValue) -> char\n"
		"get(char const * entry, char const * defaultValue, int maxSize) -> char\n"
		"Fl_Preferences_get(Fl_Preferences self, char const * entry, void * value, void const * defaultValue, \n"
		"    int defaultSize, int maxSize) -> char\n"
		""},
	 { (char *)"Fl_Preferences_size", _wrap_Fl_Preferences_size, METH_VARARGS, (char *)"Fl_Preferences_size(Fl_Preferences self, char const * entry) -> int"},
	 { (char *)"Fl_Preferences_getUserdataPath", _wrap_Fl_Preferences_getUserdataPath, METH_VARARGS, (char *)"Fl_Preferences_getUserdataPath(Fl_Preferences self, char * path) -> char"},
	 { (char *)"Fl_Preferences_flush", _wrap_Fl_Preferences_flush, METH_VARARGS, (char *)"Fl_Preferences_flush(Fl_Preferences self)"},
	 { (char *)"Fl_Preferences_swigregister", Fl_Preferences_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Progress_draw", _wrap_Fl_Progress_draw, METH_VARARGS, (char *)"Fl_Progress_draw(Fl_Progress self)"},
	 { (char *)"new_Fl_Progress", _wrap_new_Fl_Progress, METH_VARARGS, (char *)"new_Fl_Progress(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Progress"},
	 { (char *)"Fl_Progress_maximum", _wrap_Fl_Progress_maximum, METH_VARARGS, (char *)"\n"
		"maximum(float v)\n"
		"Fl_Progress_maximum(Fl_Progress self) -> float\n"
		""},
	 { (char *)"Fl_Progress_minimum", _wrap_Fl_Progress_minimum, METH_VARARGS, (char *)"\n"
		"minimum(float v)\n"
		"Fl_Progress_minimum(Fl_Progress self) -> float\n"
		""},
	 { (char *)"Fl_Progress_value", _wrap_Fl_Progress_value, METH_VARARGS, (char *)"\n"
		"value(float v)\n"
		"Fl_Progress_value(Fl_Progress self) -> float\n"
		""},
	 { (char *)"delete_Fl_Progress", _wrap_delete_Fl_Progress, METH_VARARGS, (char *)"delete_Fl_Progress(Fl_Progress self)"},
	 { (char *)"disown_Fl_Progress", _wrap_disown_Fl_Progress, METH_VARARGS, NULL},
	 { (char *)"Fl_Progress_swigregister", Fl_Progress_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Radio_Button", _wrap_new_Fl_Radio_Button, METH_VARARGS, (char *)"new_Fl_Radio_Button(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Radio_Button"},
	 { (char *)"delete_Fl_Radio_Button", _wrap_delete_Fl_Radio_Button, METH_VARARGS, (char *)"delete_Fl_Radio_Button(Fl_Radio_Button self)"},
	 { (char *)"disown_Fl_Radio_Button", _wrap_disown_Fl_Radio_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Radio_Button_draw", _wrap_Fl_Radio_Button_draw, METH_VARARGS, (char *)"Fl_Radio_Button_draw(Fl_Radio_Button self)"},
	 { (char *)"Fl_Radio_Button_swigregister", Fl_Radio_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Radio_Light_Button", _wrap_new_Fl_Radio_Light_Button, METH_VARARGS, (char *)"new_Fl_Radio_Light_Button(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Radio_Light_Button"},
	 { (char *)"delete_Fl_Radio_Light_Button", _wrap_delete_Fl_Radio_Light_Button, METH_VARARGS, (char *)"delete_Fl_Radio_Light_Button(Fl_Radio_Light_Button self)"},
	 { (char *)"disown_Fl_Radio_Light_Button", _wrap_disown_Fl_Radio_Light_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Radio_Light_Button_draw", _wrap_Fl_Radio_Light_Button_draw, METH_VARARGS, (char *)"Fl_Radio_Light_Button_draw(Fl_Radio_Light_Button self)"},
	 { (char *)"Fl_Radio_Light_Button_swigregister", Fl_Radio_Light_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Round_Button", _wrap_new_Fl_Round_Button, METH_VARARGS, (char *)"new_Fl_Round_Button(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Round_Button"},
	 { (char *)"delete_Fl_Round_Button", _wrap_delete_Fl_Round_Button, METH_VARARGS, (char *)"delete_Fl_Round_Button(Fl_Round_Button self)"},
	 { (char *)"disown_Fl_Round_Button", _wrap_disown_Fl_Round_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Round_Button_draw", _wrap_Fl_Round_Button_draw, METH_VARARGS, (char *)"Fl_Round_Button_draw(Fl_Round_Button self)"},
	 { (char *)"Fl_Round_Button_swigregister", Fl_Round_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Radio_Round_Button", _wrap_new_Fl_Radio_Round_Button, METH_VARARGS, (char *)"new_Fl_Radio_Round_Button(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Radio_Round_Button"},
	 { (char *)"delete_Fl_Radio_Round_Button", _wrap_delete_Fl_Radio_Round_Button, METH_VARARGS, (char *)"delete_Fl_Radio_Round_Button(Fl_Radio_Round_Button self)"},
	 { (char *)"disown_Fl_Radio_Round_Button", _wrap_disown_Fl_Radio_Round_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Radio_Round_Button_draw", _wrap_Fl_Radio_Round_Button_draw, METH_VARARGS, (char *)"Fl_Radio_Round_Button_draw(Fl_Radio_Round_Button self)"},
	 { (char *)"Fl_Radio_Round_Button_swigregister", Fl_Radio_Round_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Repeat_Button_handle", _wrap_Fl_Repeat_Button_handle, METH_VARARGS, (char *)"Fl_Repeat_Button_handle(Fl_Repeat_Button self, int arg0) -> int"},
	 { (char *)"new_Fl_Repeat_Button", _wrap_new_Fl_Repeat_Button, METH_VARARGS, (char *)"new_Fl_Repeat_Button(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Repeat_Button"},
	 { (char *)"Fl_Repeat_Button_deactivate", _wrap_Fl_Repeat_Button_deactivate, METH_VARARGS, (char *)"Fl_Repeat_Button_deactivate(Fl_Repeat_Button self)"},
	 { (char *)"delete_Fl_Repeat_Button", _wrap_delete_Fl_Repeat_Button, METH_VARARGS, (char *)"delete_Fl_Repeat_Button(Fl_Repeat_Button self)"},
	 { (char *)"disown_Fl_Repeat_Button", _wrap_disown_Fl_Repeat_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Repeat_Button_draw", _wrap_Fl_Repeat_Button_draw, METH_VARARGS, (char *)"Fl_Repeat_Button_draw(Fl_Repeat_Button self)"},
	 { (char *)"Fl_Repeat_Button_swigregister", Fl_Repeat_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Return_Button_draw", _wrap_Fl_Return_Button_draw, METH_VARARGS, (char *)"Fl_Return_Button_draw(Fl_Return_Button self)"},
	 { (char *)"Fl_Return_Button_handle", _wrap_Fl_Return_Button_handle, METH_VARARGS, (char *)"Fl_Return_Button_handle(Fl_Return_Button self, int arg0) -> int"},
	 { (char *)"new_Fl_Return_Button", _wrap_new_Fl_Return_Button, METH_VARARGS, (char *)"new_Fl_Return_Button(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Return_Button"},
	 { (char *)"delete_Fl_Return_Button", _wrap_delete_Fl_Return_Button, METH_VARARGS, (char *)"delete_Fl_Return_Button(Fl_Return_Button self)"},
	 { (char *)"disown_Fl_Return_Button", _wrap_disown_Fl_Return_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Return_Button_swigregister", Fl_Return_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Roller_draw", _wrap_Fl_Roller_draw, METH_VARARGS, (char *)"Fl_Roller_draw(Fl_Roller self)"},
	 { (char *)"Fl_Roller_handle", _wrap_Fl_Roller_handle, METH_VARARGS, (char *)"Fl_Roller_handle(Fl_Roller self, int arg0) -> int"},
	 { (char *)"new_Fl_Roller", _wrap_new_Fl_Roller, METH_VARARGS, (char *)"new_Fl_Roller(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Roller"},
	 { (char *)"delete_Fl_Roller", _wrap_delete_Fl_Roller, METH_VARARGS, (char *)"delete_Fl_Roller(Fl_Roller self)"},
	 { (char *)"disown_Fl_Roller", _wrap_disown_Fl_Roller, METH_VARARGS, NULL},
	 { (char *)"Fl_Roller_swigregister", Fl_Roller_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Round_Clock", _wrap_new_Fl_Round_Clock, METH_VARARGS, (char *)"new_Fl_Round_Clock(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Round_Clock"},
	 { (char *)"delete_Fl_Round_Clock", _wrap_delete_Fl_Round_Clock, METH_VARARGS, (char *)"delete_Fl_Round_Clock(Fl_Round_Clock self)"},
	 { (char *)"disown_Fl_Round_Clock", _wrap_disown_Fl_Round_Clock, METH_VARARGS, NULL},
	 { (char *)"Fl_Round_Clock_draw", _wrap_Fl_Round_Clock_draw, METH_VARARGS, (char *)"Fl_Round_Clock_draw(Fl_Round_Clock self)"},
	 { (char *)"Fl_Round_Clock_swigregister", Fl_Round_Clock_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Scroll_draw", _wrap_Fl_Scroll_draw, METH_VARARGS, (char *)"Fl_Scroll_draw(Fl_Scroll self)"},
	 { (char *)"Fl_Scroll_resize", _wrap_Fl_Scroll_resize, METH_VARARGS, (char *)"Fl_Scroll_resize(Fl_Scroll self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Scroll_handle", _wrap_Fl_Scroll_handle, METH_VARARGS, (char *)"Fl_Scroll_handle(Fl_Scroll self, int arg0) -> int"},
	 { (char *)"new_Fl_Scroll", _wrap_new_Fl_Scroll, METH_VARARGS, (char *)"new_Fl_Scroll(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Scroll"},
	 { (char *)"Fl_Scroll_xposition", _wrap_Fl_Scroll_xposition, METH_VARARGS, (char *)"Fl_Scroll_xposition(Fl_Scroll self) -> int"},
	 { (char *)"Fl_Scroll_yposition", _wrap_Fl_Scroll_yposition, METH_VARARGS, (char *)"Fl_Scroll_yposition(Fl_Scroll self) -> int"},
	 { (char *)"Fl_Scroll_scroll_to", _wrap_Fl_Scroll_scroll_to, METH_VARARGS, (char *)"Fl_Scroll_scroll_to(Fl_Scroll self, int arg2, int arg3)"},
	 { (char *)"Fl_Scroll_clear", _wrap_Fl_Scroll_clear, METH_VARARGS, (char *)"Fl_Scroll_clear(Fl_Scroll self)"},
	 { (char *)"Fl_Scroll_scrollbar_size", _wrap_Fl_Scroll_scrollbar_size, METH_VARARGS, (char *)"\n"
		"scrollbar_size() -> int\n"
		"Fl_Scroll_scrollbar_size(Fl_Scroll self, int newSize)\n"
		""},
	 { (char *)"Fl_Scroll_getScrollbar", _wrap_Fl_Scroll_getScrollbar, METH_VARARGS, (char *)"Fl_Scroll_getScrollbar(Fl_Scroll self) -> Fl_Scrollbar"},
	 { (char *)"Fl_Scroll_getHScrollbar", _wrap_Fl_Scroll_getHScrollbar, METH_VARARGS, (char *)"Fl_Scroll_getHScrollbar(Fl_Scroll self) -> Fl_Scrollbar"},
	 { (char *)"delete_Fl_Scroll", _wrap_delete_Fl_Scroll, METH_VARARGS, (char *)"delete_Fl_Scroll(Fl_Scroll self)"},
	 { (char *)"disown_Fl_Scroll", _wrap_disown_Fl_Scroll, METH_VARARGS, NULL},
	 { (char *)"Fl_Scroll_swigregister", Fl_Scroll_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Scrollbar_draw", _wrap_Fl_Scrollbar_draw, METH_VARARGS, (char *)"Fl_Scrollbar_draw(Fl_Scrollbar self)"},
	 { (char *)"new_Fl_Scrollbar", _wrap_new_Fl_Scrollbar, METH_VARARGS, (char *)"new_Fl_Scrollbar(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Scrollbar"},
	 { (char *)"delete_Fl_Scrollbar", _wrap_delete_Fl_Scrollbar, METH_VARARGS, (char *)"delete_Fl_Scrollbar(Fl_Scrollbar self)"},
	 { (char *)"Fl_Scrollbar_handle", _wrap_Fl_Scrollbar_handle, METH_VARARGS, (char *)"Fl_Scrollbar_handle(Fl_Scrollbar self, int arg0) -> int"},
	 { (char *)"Fl_Scrollbar_value", _wrap_Fl_Scrollbar_value, METH_VARARGS, (char *)"\n"
		"value() -> int\n"
		"value(int p) -> int\n"
		"Fl_Scrollbar_value(Fl_Scrollbar self, int pos, int windowSize, int first, int total) -> int\n"
		""},
	 { (char *)"Fl_Scrollbar_linesize", _wrap_Fl_Scrollbar_linesize, METH_VARARGS, (char *)"\n"
		"linesize() -> int\n"
		"Fl_Scrollbar_linesize(Fl_Scrollbar self, int i)\n"
		""},
	 { (char *)"disown_Fl_Scrollbar", _wrap_disown_Fl_Scrollbar, METH_VARARGS, NULL},
	 { (char *)"Fl_Scrollbar_swigregister", Fl_Scrollbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Secret_Input", _wrap_new_Fl_Secret_Input, METH_VARARGS, (char *)"new_Fl_Secret_Input(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Secret_Input"},
	 { (char *)"Fl_Secret_Input_handle", _wrap_Fl_Secret_Input_handle, METH_VARARGS, (char *)"Fl_Secret_Input_handle(Fl_Secret_Input self, int arg0) -> int"},
	 { (char *)"delete_Fl_Secret_Input", _wrap_delete_Fl_Secret_Input, METH_VARARGS, (char *)"delete_Fl_Secret_Input(Fl_Secret_Input self)"},
	 { (char *)"disown_Fl_Secret_Input", _wrap_disown_Fl_Secret_Input, METH_VARARGS, NULL},
	 { (char *)"Fl_Secret_Input_draw", _wrap_Fl_Secret_Input_draw, METH_VARARGS, (char *)"Fl_Secret_Input_draw(Fl_Secret_Input self)"},
	 { (char *)"Fl_Secret_Input_swigregister", Fl_Secret_Input_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Select_Browser", _wrap_new_Fl_Select_Browser, METH_VARARGS, (char *)"new_Fl_Select_Browser(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Select_Browser"},
	 { (char *)"delete_Fl_Select_Browser", _wrap_delete_Fl_Select_Browser, METH_VARARGS, (char *)"delete_Fl_Select_Browser(Fl_Select_Browser self)"},
	 { (char *)"disown_Fl_Select_Browser", _wrap_disown_Fl_Select_Browser, METH_VARARGS, NULL},
	 { (char *)"Fl_Select_Browser_draw", _wrap_Fl_Select_Browser_draw, METH_VARARGS, (char *)"Fl_Select_Browser_draw(Fl_Select_Browser self)"},
	 { (char *)"Fl_Select_Browser_item_first", _wrap_Fl_Select_Browser_item_first, METH_VARARGS, (char *)"Fl_Select_Browser_item_first(Fl_Select_Browser self) -> void *"},
	 { (char *)"Fl_Select_Browser_item_next", _wrap_Fl_Select_Browser_item_next, METH_VARARGS, (char *)"Fl_Select_Browser_item_next(Fl_Select_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Select_Browser_item_prev", _wrap_Fl_Select_Browser_item_prev, METH_VARARGS, (char *)"Fl_Select_Browser_item_prev(Fl_Select_Browser self, void * item) -> void *"},
	 { (char *)"Fl_Select_Browser_item_last", _wrap_Fl_Select_Browser_item_last, METH_VARARGS, (char *)"Fl_Select_Browser_item_last(Fl_Select_Browser self) -> void *"},
	 { (char *)"Fl_Select_Browser_item_height", _wrap_Fl_Select_Browser_item_height, METH_VARARGS, (char *)"Fl_Select_Browser_item_height(Fl_Select_Browser self, void * item) -> int"},
	 { (char *)"Fl_Select_Browser_item_width", _wrap_Fl_Select_Browser_item_width, METH_VARARGS, (char *)"Fl_Select_Browser_item_width(Fl_Select_Browser self, void * item) -> int"},
	 { (char *)"Fl_Select_Browser_item_quick_height", _wrap_Fl_Select_Browser_item_quick_height, METH_VARARGS, (char *)"Fl_Select_Browser_item_quick_height(Fl_Select_Browser self, void * item) -> int"},
	 { (char *)"Fl_Select_Browser_item_draw", _wrap_Fl_Select_Browser_item_draw, METH_VARARGS, (char *)"Fl_Select_Browser_item_draw(Fl_Select_Browser self, void * item, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Select_Browser_item_text", _wrap_Fl_Select_Browser_item_text, METH_VARARGS, (char *)"Fl_Select_Browser_item_text(Fl_Select_Browser self, void * item) -> char const *"},
	 { (char *)"Fl_Select_Browser_item_swap", _wrap_Fl_Select_Browser_item_swap, METH_VARARGS, (char *)"Fl_Select_Browser_item_swap(Fl_Select_Browser self, void * a, void * b)"},
	 { (char *)"Fl_Select_Browser_item_at", _wrap_Fl_Select_Browser_item_at, METH_VARARGS, (char *)"Fl_Select_Browser_item_at(Fl_Select_Browser self, int line) -> void *"},
	 { (char *)"Fl_Select_Browser_full_width", _wrap_Fl_Select_Browser_full_width, METH_VARARGS, (char *)"Fl_Select_Browser_full_width(Fl_Select_Browser self) -> int"},
	 { (char *)"Fl_Select_Browser_full_height", _wrap_Fl_Select_Browser_full_height, METH_VARARGS, (char *)"Fl_Select_Browser_full_height(Fl_Select_Browser self) -> int"},
	 { (char *)"Fl_Select_Browser_incr_height", _wrap_Fl_Select_Browser_incr_height, METH_VARARGS, (char *)"Fl_Select_Browser_incr_height(Fl_Select_Browser self) -> int"},
	 { (char *)"Fl_Select_Browser_item_select", _wrap_Fl_Select_Browser_item_select, METH_VARARGS, (char *)"Fl_Select_Browser_item_select(Fl_Select_Browser self, void * item, int val)"},
	 { (char *)"Fl_Select_Browser_item_selected", _wrap_Fl_Select_Browser_item_selected, METH_VARARGS, (char *)"Fl_Select_Browser_item_selected(Fl_Select_Browser self, void * item) -> int"},
	 { (char *)"Fl_Select_Browser_swigregister", Fl_Select_Browser_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Shared_Image", _wrap_new_Fl_Shared_Image, METH_VARARGS, (char *)"\n"
		"Fl_Shared_Image()\n"
		"new_Fl_Shared_Image(PyObject * self, char const * n, Fl_Image img=None) -> Fl_Shared_Image\n"
		""},
	 { (char *)"Fl_Shared_Image_name", _wrap_Fl_Shared_Image_name, METH_VARARGS, (char *)"Fl_Shared_Image_name(Fl_Shared_Image self) -> char const *"},
	 { (char *)"Fl_Shared_Image_refcount", _wrap_Fl_Shared_Image_refcount, METH_VARARGS, (char *)"Fl_Shared_Image_refcount(Fl_Shared_Image self) -> int"},
	 { (char *)"Fl_Shared_Image_release", _wrap_Fl_Shared_Image_release, METH_VARARGS, (char *)"Fl_Shared_Image_release(Fl_Shared_Image self)"},
	 { (char *)"Fl_Shared_Image_reload", _wrap_Fl_Shared_Image_reload, METH_VARARGS, (char *)"Fl_Shared_Image_reload(Fl_Shared_Image self)"},
	 { (char *)"Fl_Shared_Image_copy", _wrap_Fl_Shared_Image_copy, METH_VARARGS, (char *)"\n"
		"copy(int W, int H) -> Fl_Image\n"
		"Fl_Shared_Image_copy(Fl_Shared_Image self) -> Fl_Image\n"
		""},
	 { (char *)"Fl_Shared_Image_color_average", _wrap_Fl_Shared_Image_color_average, METH_VARARGS, (char *)"Fl_Shared_Image_color_average(Fl_Shared_Image self, Fl_Color c, float i)"},
	 { (char *)"Fl_Shared_Image_desaturate", _wrap_Fl_Shared_Image_desaturate, METH_VARARGS, (char *)"Fl_Shared_Image_desaturate(Fl_Shared_Image self)"},
	 { (char *)"Fl_Shared_Image_draw", _wrap_Fl_Shared_Image_draw, METH_VARARGS, (char *)"\n"
		"draw(int X, int Y, int W, int H, int cx, int cy)\n"
		"Fl_Shared_Image_draw(Fl_Shared_Image self, int X, int Y)\n"
		""},
	 { (char *)"Fl_Shared_Image_scale", _wrap_Fl_Shared_Image_scale, METH_VARARGS, (char *)"Fl_Shared_Image_scale(Fl_Shared_Image self, int width, int height, int proportional=1, int can_expand=0)"},
	 { (char *)"Fl_Shared_Image_uncache", _wrap_Fl_Shared_Image_uncache, METH_VARARGS, (char *)"Fl_Shared_Image_uncache(Fl_Shared_Image self)"},
	 { (char *)"Fl_Shared_Image_find", _wrap_Fl_Shared_Image_find, METH_VARARGS, (char *)"Fl_Shared_Image_find(char const * name, int W=0, int H=0) -> Fl_Shared_Image"},
	 { (char *)"Fl_Shared_Image_get", _wrap_Fl_Shared_Image_get, METH_VARARGS, (char *)"\n"
		"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"
		""},
	 { (char *)"Fl_Shared_Image_images", _wrap_Fl_Shared_Image_images, METH_VARARGS, (char *)"Fl_Shared_Image_images() -> Fl_Shared_Image **"},
	 { (char *)"Fl_Shared_Image_num_images", _wrap_Fl_Shared_Image_num_images, METH_VARARGS, (char *)"Fl_Shared_Image_num_images() -> int"},
	 { (char *)"Fl_Shared_Image_add_handler", _wrap_Fl_Shared_Image_add_handler, METH_VARARGS, (char *)"Fl_Shared_Image_add_handler(Fl_Shared_Handler f)"},
	 { (char *)"Fl_Shared_Image_remove_handler", _wrap_Fl_Shared_Image_remove_handler, METH_VARARGS, (char *)"Fl_Shared_Image_remove_handler(Fl_Shared_Handler f)"},
	 { (char *)"Fl_Shared_Image_scaling_algorithm", _wrap_Fl_Shared_Image_scaling_algorithm, METH_VARARGS, (char *)"Fl_Shared_Image_scaling_algorithm(Fl_RGB_Scaling algorithm)"},
	 { (char *)"disown_Fl_Shared_Image", _wrap_disown_Fl_Shared_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_Shared_Image_swigregister", Fl_Shared_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_register_images", _wrap_fl_register_images, METH_VARARGS, (char *)"fl_register_images()"},
	 { (char *)"new_Fl_Spinner", _wrap_new_Fl_Spinner, METH_VARARGS, (char *)"new_Fl_Spinner(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Spinner"},
	 { (char *)"Fl_Spinner_format", _wrap_Fl_Spinner_format, METH_VARARGS, (char *)"\n"
		"format() -> char const\n"
		"Fl_Spinner_format(Fl_Spinner self, char const * f)\n"
		""},
	 { (char *)"Fl_Spinner_handle", _wrap_Fl_Spinner_handle, METH_VARARGS, (char *)"Fl_Spinner_handle(Fl_Spinner self, int event) -> int"},
	 { (char *)"Fl_Spinner_maxinum", _wrap_Fl_Spinner_maxinum, METH_VARARGS, (char *)"Fl_Spinner_maxinum(Fl_Spinner self) -> double"},
	 { (char *)"Fl_Spinner_mininum", _wrap_Fl_Spinner_mininum, METH_VARARGS, (char *)"Fl_Spinner_mininum(Fl_Spinner self) -> double"},
	 { (char *)"Fl_Spinner_range", _wrap_Fl_Spinner_range, METH_VARARGS, (char *)"Fl_Spinner_range(Fl_Spinner self, double a, double b)"},
	 { (char *)"Fl_Spinner_resize", _wrap_Fl_Spinner_resize, METH_VARARGS, (char *)"Fl_Spinner_resize(Fl_Spinner self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Spinner_step", _wrap_Fl_Spinner_step, METH_VARARGS, (char *)"\n"
		"step() -> double\n"
		"Fl_Spinner_step(Fl_Spinner self, double s)\n"
		""},
	 { (char *)"Fl_Spinner_textcolor", _wrap_Fl_Spinner_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Spinner_textcolor(Fl_Spinner self, Fl_Color c)\n"
		""},
	 { (char *)"Fl_Spinner_textfont", _wrap_Fl_Spinner_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Spinner_textfont(Fl_Spinner self, Fl_Font f)\n"
		""},
	 { (char *)"Fl_Spinner_textsize", _wrap_Fl_Spinner_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Spinner_textsize(Fl_Spinner self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Spinner_type", _wrap_Fl_Spinner_type, METH_VARARGS, (char *)"\n"
		"type() -> uchar\n"
		"Fl_Spinner_type(Fl_Spinner self, uchar v)\n"
		""},
	 { (char *)"Fl_Spinner_value", _wrap_Fl_Spinner_value, METH_VARARGS, (char *)"\n"
		"value() -> double\n"
		"Fl_Spinner_value(Fl_Spinner self, double v)\n"
		""},
	 { (char *)"Fl_Spinner_color", _wrap_Fl_Spinner_color, METH_VARARGS, (char *)"\n"
		"color(Fl_Color v)\n"
		"Fl_Spinner_color(Fl_Spinner self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Spinner_selection_color", _wrap_Fl_Spinner_selection_color, METH_VARARGS, (char *)"\n"
		"selection_color(Fl_Color val)\n"
		"Fl_Spinner_selection_color(Fl_Spinner self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Spinner_minimum", _wrap_Fl_Spinner_minimum, METH_VARARGS, (char *)"\n"
		"minimum(double m)\n"
		"Fl_Spinner_minimum(Fl_Spinner self) -> double\n"
		""},
	 { (char *)"Fl_Spinner_maximum", _wrap_Fl_Spinner_maximum, METH_VARARGS, (char *)"\n"
		"maximum(double m)\n"
		"Fl_Spinner_maximum(Fl_Spinner self) -> double\n"
		""},
	 { (char *)"delete_Fl_Spinner", _wrap_delete_Fl_Spinner, METH_VARARGS, (char *)"delete_Fl_Spinner(Fl_Spinner self)"},
	 { (char *)"disown_Fl_Spinner", _wrap_disown_Fl_Spinner, METH_VARARGS, NULL},
	 { (char *)"Fl_Spinner_draw", _wrap_Fl_Spinner_draw, METH_VARARGS, (char *)"Fl_Spinner_draw(Fl_Spinner self)"},
	 { (char *)"Fl_Spinner_swigregister", Fl_Spinner_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_show_colormap", _wrap_fl_show_colormap, METH_VARARGS, (char *)"fl_show_colormap(Fl_Color oldcol) -> Fl_Color"},
	 { (char *)"new_Fl_Simple_Counter", _wrap_new_Fl_Simple_Counter, METH_VARARGS, (char *)"new_Fl_Simple_Counter(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Simple_Counter"},
	 { (char *)"delete_Fl_Simple_Counter", _wrap_delete_Fl_Simple_Counter, METH_VARARGS, (char *)"delete_Fl_Simple_Counter(Fl_Simple_Counter self)"},
	 { (char *)"disown_Fl_Simple_Counter", _wrap_disown_Fl_Simple_Counter, METH_VARARGS, NULL},
	 { (char *)"Fl_Simple_Counter_draw", _wrap_Fl_Simple_Counter_draw, METH_VARARGS, (char *)"Fl_Simple_Counter_draw(Fl_Simple_Counter self)"},
	 { (char *)"Fl_Simple_Counter_swigregister", Fl_Simple_Counter_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Tabs_draw", _wrap_Fl_Tabs_draw, METH_VARARGS, (char *)"Fl_Tabs_draw(Fl_Tabs self)"},
	 { (char *)"Fl_Tabs_handle", _wrap_Fl_Tabs_handle, METH_VARARGS, (char *)"Fl_Tabs_handle(Fl_Tabs self, int arg0) -> int"},
	 { (char *)"Fl_Tabs_value", _wrap_Fl_Tabs_value, METH_VARARGS, (char *)"\n"
		"value() -> Fl_Widget\n"
		"Fl_Tabs_value(Fl_Tabs self, Fl_Widget arg2) -> int\n"
		""},
	 { (char *)"Fl_Tabs_push", _wrap_Fl_Tabs_push, METH_VARARGS, (char *)"\n"
		"push() -> Fl_Widget\n"
		"Fl_Tabs_push(Fl_Tabs self, Fl_Widget arg2) -> int\n"
		""},
	 { (char *)"new_Fl_Tabs", _wrap_new_Fl_Tabs, METH_VARARGS, (char *)"new_Fl_Tabs(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Tabs"},
	 { (char *)"Fl_Tabs_which", _wrap_Fl_Tabs_which, METH_VARARGS, (char *)"Fl_Tabs_which(Fl_Tabs self, int event_x, int event_y) -> Fl_Widget"},
	 { (char *)"delete_Fl_Tabs", _wrap_delete_Fl_Tabs, METH_VARARGS, (char *)"delete_Fl_Tabs(Fl_Tabs self)"},
	 { (char *)"Fl_Tabs_client_area", _wrap_Fl_Tabs_client_area, METH_VARARGS, (char *)"Fl_Tabs_client_area(Fl_Tabs self, int tabh=0)"},
	 { (char *)"disown_Fl_Tabs", _wrap_disown_Fl_Tabs, METH_VARARGS, NULL},
	 { (char *)"Fl_Tabs_swigregister", Fl_Tabs_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Text_Selection_set", _wrap_Fl_Text_Selection_set, METH_VARARGS, (char *)"Fl_Text_Selection_set(Fl_Text_Selection self, int start, int end)"},
	 { (char *)"Fl_Text_Selection_update", _wrap_Fl_Text_Selection_update, METH_VARARGS, (char *)"Fl_Text_Selection_update(Fl_Text_Selection self, int pos, int nDeleted, int nInserted)"},
	 { (char *)"Fl_Text_Selection_start", _wrap_Fl_Text_Selection_start, METH_VARARGS, (char *)"Fl_Text_Selection_start(Fl_Text_Selection self) -> int"},
	 { (char *)"Fl_Text_Selection_end", _wrap_Fl_Text_Selection_end, METH_VARARGS, (char *)"Fl_Text_Selection_end(Fl_Text_Selection self) -> int"},
	 { (char *)"Fl_Text_Selection_selected", _wrap_Fl_Text_Selection_selected, METH_VARARGS, (char *)"\n"
		"selected() -> bool\n"
		"Fl_Text_Selection_selected(Fl_Text_Selection self, bool b)\n"
		""},
	 { (char *)"Fl_Text_Selection_includes", _wrap_Fl_Text_Selection_includes, METH_VARARGS, (char *)"Fl_Text_Selection_includes(Fl_Text_Selection self, int pos) -> int"},
	 { (char *)"Fl_Text_Selection_position", _wrap_Fl_Text_Selection_position, METH_VARARGS, (char *)"Fl_Text_Selection_position(Fl_Text_Selection self, int * start, int * end) -> int"},
	 { (char *)"new_Fl_Text_Selection", _wrap_new_Fl_Text_Selection, METH_VARARGS, (char *)"new_Fl_Text_Selection() -> Fl_Text_Selection"},
	 { (char *)"delete_Fl_Text_Selection", _wrap_delete_Fl_Text_Selection, METH_VARARGS, (char *)"delete_Fl_Text_Selection(Fl_Text_Selection self)"},
	 { (char *)"Fl_Text_Selection_swigregister", Fl_Text_Selection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Text_Buffer", _wrap_new_Fl_Text_Buffer, METH_VARARGS, (char *)"new_Fl_Text_Buffer(int requestedSize=0, int preferredGapSize=1024) -> Fl_Text_Buffer"},
	 { (char *)"delete_Fl_Text_Buffer", _wrap_delete_Fl_Text_Buffer, METH_VARARGS, (char *)"delete_Fl_Text_Buffer(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_length", _wrap_Fl_Text_Buffer_length, METH_VARARGS, (char *)"Fl_Text_Buffer_length(Fl_Text_Buffer self) -> int"},
	 { (char *)"Fl_Text_Buffer_text", _wrap_Fl_Text_Buffer_text, METH_VARARGS, (char *)"\n"
		"text() -> char\n"
		"Fl_Text_Buffer_text(Fl_Text_Buffer self, char const * text)\n"
		""},
	 { (char *)"Fl_Text_Buffer_text_range", _wrap_Fl_Text_Buffer_text_range, METH_VARARGS, (char *)"Fl_Text_Buffer_text_range(Fl_Text_Buffer self, int start, int end) -> char *"},
	 { (char *)"Fl_Text_Buffer_char_at", _wrap_Fl_Text_Buffer_char_at, METH_VARARGS, (char *)"Fl_Text_Buffer_char_at(Fl_Text_Buffer self, int pos) -> unsigned int"},
	 { (char *)"Fl_Text_Buffer_byte_at", _wrap_Fl_Text_Buffer_byte_at, METH_VARARGS, (char *)"Fl_Text_Buffer_byte_at(Fl_Text_Buffer self, int pos) -> char"},
	 { (char *)"Fl_Text_Buffer_address", _wrap_Fl_Text_Buffer_address, METH_VARARGS, (char *)"\n"
		"address(int pos) -> char const\n"
		"Fl_Text_Buffer_address(Fl_Text_Buffer self, int pos) -> char *\n"
		""},
	 { (char *)"Fl_Text_Buffer_insert", _wrap_Fl_Text_Buffer_insert, METH_VARARGS, (char *)"Fl_Text_Buffer_insert(Fl_Text_Buffer self, int pos, char const * text)"},
	 { (char *)"Fl_Text_Buffer_append", _wrap_Fl_Text_Buffer_append, METH_VARARGS, (char *)"Fl_Text_Buffer_append(Fl_Text_Buffer self, char const * t)"},
	 { (char *)"Fl_Text_Buffer_remove", _wrap_Fl_Text_Buffer_remove, METH_VARARGS, (char *)"Fl_Text_Buffer_remove(Fl_Text_Buffer self, int start, int end)"},
	 { (char *)"Fl_Text_Buffer_replace", _wrap_Fl_Text_Buffer_replace, METH_VARARGS, (char *)"Fl_Text_Buffer_replace(Fl_Text_Buffer self, int start, int end, char const * text)"},
	 { (char *)"Fl_Text_Buffer_copy", _wrap_Fl_Text_Buffer_copy, METH_VARARGS, (char *)"Fl_Text_Buffer_copy(Fl_Text_Buffer self, Fl_Text_Buffer fromBuf, int fromStart, int fromEnd, int toPos)"},
	 { (char *)"Fl_Text_Buffer_undo", _wrap_Fl_Text_Buffer_undo, METH_VARARGS, (char *)"Fl_Text_Buffer_undo(Fl_Text_Buffer self, int * cp=None) -> int"},
	 { (char *)"Fl_Text_Buffer_canUndo", _wrap_Fl_Text_Buffer_canUndo, METH_VARARGS, (char *)"Fl_Text_Buffer_canUndo(Fl_Text_Buffer self, char flag=1)"},
	 { (char *)"Fl_Text_Buffer_insertfile", _wrap_Fl_Text_Buffer_insertfile, METH_VARARGS, (char *)"Fl_Text_Buffer_insertfile(Fl_Text_Buffer self, char const * file, int pos, int buflen=128*1024) -> int"},
	 { (char *)"Fl_Text_Buffer_appendfile", _wrap_Fl_Text_Buffer_appendfile, METH_VARARGS, (char *)"Fl_Text_Buffer_appendfile(Fl_Text_Buffer self, char const * file, int buflen=128*1024) -> int"},
	 { (char *)"Fl_Text_Buffer_loadfile", _wrap_Fl_Text_Buffer_loadfile, METH_VARARGS, (char *)"Fl_Text_Buffer_loadfile(Fl_Text_Buffer self, char const * file, int buflen=128*1024) -> int"},
	 { (char *)"Fl_Text_Buffer_outputfile", _wrap_Fl_Text_Buffer_outputfile, METH_VARARGS, (char *)"Fl_Text_Buffer_outputfile(Fl_Text_Buffer self, char const * file, int start, int end, int buflen=128*1024) -> int"},
	 { (char *)"Fl_Text_Buffer_savefile", _wrap_Fl_Text_Buffer_savefile, METH_VARARGS, (char *)"Fl_Text_Buffer_savefile(Fl_Text_Buffer self, char const * file, int buflen=128*1024) -> int"},
	 { (char *)"Fl_Text_Buffer_tab_distance", _wrap_Fl_Text_Buffer_tab_distance, METH_VARARGS, (char *)"\n"
		"tab_distance() -> int\n"
		"Fl_Text_Buffer_tab_distance(Fl_Text_Buffer self, int tabDist)\n"
		""},
	 { (char *)"Fl_Text_Buffer_select", _wrap_Fl_Text_Buffer_select, METH_VARARGS, (char *)"Fl_Text_Buffer_select(Fl_Text_Buffer self, int start, int end)"},
	 { (char *)"Fl_Text_Buffer_selected", _wrap_Fl_Text_Buffer_selected, METH_VARARGS, (char *)"Fl_Text_Buffer_selected(Fl_Text_Buffer self) -> int"},
	 { (char *)"Fl_Text_Buffer_unselect", _wrap_Fl_Text_Buffer_unselect, METH_VARARGS, (char *)"Fl_Text_Buffer_unselect(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_selection_position", _wrap_Fl_Text_Buffer_selection_position, METH_VARARGS, (char *)"Fl_Text_Buffer_selection_position(Fl_Text_Buffer self, int * start, int * end) -> int"},
	 { (char *)"Fl_Text_Buffer_selection_text", _wrap_Fl_Text_Buffer_selection_text, METH_VARARGS, (char *)"Fl_Text_Buffer_selection_text(Fl_Text_Buffer self) -> char *"},
	 { (char *)"Fl_Text_Buffer_remove_selection", _wrap_Fl_Text_Buffer_remove_selection, METH_VARARGS, (char *)"Fl_Text_Buffer_remove_selection(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_replace_selection", _wrap_Fl_Text_Buffer_replace_selection, METH_VARARGS, (char *)"Fl_Text_Buffer_replace_selection(Fl_Text_Buffer self, char const * text)"},
	 { (char *)"Fl_Text_Buffer_secondary_select", _wrap_Fl_Text_Buffer_secondary_select, METH_VARARGS, (char *)"Fl_Text_Buffer_secondary_select(Fl_Text_Buffer self, int start, int end)"},
	 { (char *)"Fl_Text_Buffer_secondary_selected", _wrap_Fl_Text_Buffer_secondary_selected, METH_VARARGS, (char *)"Fl_Text_Buffer_secondary_selected(Fl_Text_Buffer self) -> int"},
	 { (char *)"Fl_Text_Buffer_secondary_unselect", _wrap_Fl_Text_Buffer_secondary_unselect, METH_VARARGS, (char *)"Fl_Text_Buffer_secondary_unselect(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_secondary_selection_position", _wrap_Fl_Text_Buffer_secondary_selection_position, METH_VARARGS, (char *)"Fl_Text_Buffer_secondary_selection_position(Fl_Text_Buffer self, int * start, int * end) -> int"},
	 { (char *)"Fl_Text_Buffer_secondary_selection_text", _wrap_Fl_Text_Buffer_secondary_selection_text, METH_VARARGS, (char *)"Fl_Text_Buffer_secondary_selection_text(Fl_Text_Buffer self) -> char *"},
	 { (char *)"Fl_Text_Buffer_remove_secondary_selection", _wrap_Fl_Text_Buffer_remove_secondary_selection, METH_VARARGS, (char *)"Fl_Text_Buffer_remove_secondary_selection(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_replace_secondary_selection", _wrap_Fl_Text_Buffer_replace_secondary_selection, METH_VARARGS, (char *)"Fl_Text_Buffer_replace_secondary_selection(Fl_Text_Buffer self, char const * text)"},
	 { (char *)"Fl_Text_Buffer_highlight", _wrap_Fl_Text_Buffer_highlight, METH_VARARGS, (char *)"\n"
		"highlight(int start, int end)\n"
		"Fl_Text_Buffer_highlight(Fl_Text_Buffer self) -> int\n"
		""},
	 { (char *)"Fl_Text_Buffer_unhighlight", _wrap_Fl_Text_Buffer_unhighlight, METH_VARARGS, (char *)"Fl_Text_Buffer_unhighlight(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_highlight_position", _wrap_Fl_Text_Buffer_highlight_position, METH_VARARGS, (char *)"Fl_Text_Buffer_highlight_position(Fl_Text_Buffer self, int * start, int * end) -> int"},
	 { (char *)"Fl_Text_Buffer_highlight_text", _wrap_Fl_Text_Buffer_highlight_text, METH_VARARGS, (char *)"Fl_Text_Buffer_highlight_text(Fl_Text_Buffer self) -> char *"},
	 { (char *)"Fl_Text_Buffer_call_modify_callbacks", _wrap_Fl_Text_Buffer_call_modify_callbacks, METH_VARARGS, (char *)"Fl_Text_Buffer_call_modify_callbacks(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_add_predelete_callback", _wrap_Fl_Text_Buffer_add_predelete_callback, METH_VARARGS, (char *)"Fl_Text_Buffer_add_predelete_callback(Fl_Text_Buffer self, Fl_Text_Predelete_Cb bufPredelCB, void * cbArg)"},
	 { (char *)"Fl_Text_Buffer_remove_predelete_callback", _wrap_Fl_Text_Buffer_remove_predelete_callback, METH_VARARGS, (char *)"Fl_Text_Buffer_remove_predelete_callback(Fl_Text_Buffer self, Fl_Text_Predelete_Cb predelCB, void * cbArg)"},
	 { (char *)"Fl_Text_Buffer_call_predelete_callbacks", _wrap_Fl_Text_Buffer_call_predelete_callbacks, METH_VARARGS, (char *)"Fl_Text_Buffer_call_predelete_callbacks(Fl_Text_Buffer self)"},
	 { (char *)"Fl_Text_Buffer_line_text", _wrap_Fl_Text_Buffer_line_text, METH_VARARGS, (char *)"Fl_Text_Buffer_line_text(Fl_Text_Buffer self, int pos) -> char *"},
	 { (char *)"Fl_Text_Buffer_line_start", _wrap_Fl_Text_Buffer_line_start, METH_VARARGS, (char *)"Fl_Text_Buffer_line_start(Fl_Text_Buffer self, int pos) -> int"},
	 { (char *)"Fl_Text_Buffer_line_end", _wrap_Fl_Text_Buffer_line_end, METH_VARARGS, (char *)"Fl_Text_Buffer_line_end(Fl_Text_Buffer self, int pos) -> int"},
	 { (char *)"Fl_Text_Buffer_word_start", _wrap_Fl_Text_Buffer_word_start, METH_VARARGS, (char *)"Fl_Text_Buffer_word_start(Fl_Text_Buffer self, int pos) -> int"},
	 { (char *)"Fl_Text_Buffer_word_end", _wrap_Fl_Text_Buffer_word_end, METH_VARARGS, (char *)"Fl_Text_Buffer_word_end(Fl_Text_Buffer self, int pos) -> int"},
	 { (char *)"Fl_Text_Buffer_count_displayed_characters", _wrap_Fl_Text_Buffer_count_displayed_characters, METH_VARARGS, (char *)"Fl_Text_Buffer_count_displayed_characters(Fl_Text_Buffer self, int lineStartPos, int targetPos) -> int"},
	 { (char *)"Fl_Text_Buffer_skip_displayed_characters", _wrap_Fl_Text_Buffer_skip_displayed_characters, METH_VARARGS, (char *)"Fl_Text_Buffer_skip_displayed_characters(Fl_Text_Buffer self, int lineStartPos, int nChars) -> int"},
	 { (char *)"Fl_Text_Buffer_count_lines", _wrap_Fl_Text_Buffer_count_lines, METH_VARARGS, (char *)"Fl_Text_Buffer_count_lines(Fl_Text_Buffer self, int startPos, int endPos) -> int"},
	 { (char *)"Fl_Text_Buffer_skip_lines", _wrap_Fl_Text_Buffer_skip_lines, METH_VARARGS, (char *)"Fl_Text_Buffer_skip_lines(Fl_Text_Buffer self, int startPos, int nLines) -> int"},
	 { (char *)"Fl_Text_Buffer_rewind_lines", _wrap_Fl_Text_Buffer_rewind_lines, METH_VARARGS, (char *)"Fl_Text_Buffer_rewind_lines(Fl_Text_Buffer self, int startPos, int nLines) -> int"},
	 { (char *)"Fl_Text_Buffer_findchar_forward", _wrap_Fl_Text_Buffer_findchar_forward, METH_VARARGS, (char *)"Fl_Text_Buffer_findchar_forward(Fl_Text_Buffer self, int startPos, unsigned int searchChar) -> int"},
	 { (char *)"Fl_Text_Buffer_findchar_backward", _wrap_Fl_Text_Buffer_findchar_backward, METH_VARARGS, (char *)"Fl_Text_Buffer_findchar_backward(Fl_Text_Buffer self, int startPos, unsigned int searchChar) -> int"},
	 { (char *)"Fl_Text_Buffer_search_forward", _wrap_Fl_Text_Buffer_search_forward, METH_VARARGS, (char *)"Fl_Text_Buffer_search_forward(Fl_Text_Buffer self, int startPos, char const * searchString, int matchCase=0) -> int"},
	 { (char *)"Fl_Text_Buffer_search_backward", _wrap_Fl_Text_Buffer_search_backward, METH_VARARGS, (char *)"Fl_Text_Buffer_search_backward(Fl_Text_Buffer self, int startPos, char const * searchString, int matchCase=0) -> int"},
	 { (char *)"Fl_Text_Buffer_primary_selection", _wrap_Fl_Text_Buffer_primary_selection, METH_VARARGS, (char *)"\n"
		"primary_selection() -> Fl_Text_Selection\n"
		"Fl_Text_Buffer_primary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection\n"
		""},
	 { (char *)"Fl_Text_Buffer_secondary_selection", _wrap_Fl_Text_Buffer_secondary_selection, METH_VARARGS, (char *)"Fl_Text_Buffer_secondary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection"},
	 { (char *)"Fl_Text_Buffer_highlight_selection", _wrap_Fl_Text_Buffer_highlight_selection, METH_VARARGS, (char *)"Fl_Text_Buffer_highlight_selection(Fl_Text_Buffer self) -> Fl_Text_Selection"},
	 { (char *)"Fl_Text_Buffer_prev_char", _wrap_Fl_Text_Buffer_prev_char, METH_VARARGS, (char *)"Fl_Text_Buffer_prev_char(Fl_Text_Buffer self, int ix) -> int"},
	 { (char *)"Fl_Text_Buffer_prev_char_clipped", _wrap_Fl_Text_Buffer_prev_char_clipped, METH_VARARGS, (char *)"Fl_Text_Buffer_prev_char_clipped(Fl_Text_Buffer self, int ix) -> int"},
	 { (char *)"Fl_Text_Buffer_next_char", _wrap_Fl_Text_Buffer_next_char, METH_VARARGS, (char *)"Fl_Text_Buffer_next_char(Fl_Text_Buffer self, int ix) -> int"},
	 { (char *)"Fl_Text_Buffer_next_char_clipped", _wrap_Fl_Text_Buffer_next_char_clipped, METH_VARARGS, (char *)"Fl_Text_Buffer_next_char_clipped(Fl_Text_Buffer self, int ix) -> int"},
	 { (char *)"Fl_Text_Buffer_utf8_align", _wrap_Fl_Text_Buffer_utf8_align, METH_VARARGS, (char *)"Fl_Text_Buffer_utf8_align(Fl_Text_Buffer self, int arg2) -> int"},
	 { (char *)"Fl_Text_Buffer_add_modify_callback", _wrap_Fl_Text_Buffer_add_modify_callback, METH_VARARGS, (char *)"\n"
		"add_modify_callback(Fl_Text_Modify_Cb bufModifiedCB, void * cbArg)\n"
		"Fl_Text_Buffer_add_modify_callback(Fl_Text_Buffer self, PyObject * PyFunc, PyObject * PyTarget=None)\n"
		""},
	 { (char *)"Fl_Text_Buffer_remove_modify_callback", _wrap_Fl_Text_Buffer_remove_modify_callback, METH_VARARGS, (char *)"\n"
		"remove_modify_callback(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"
		""},
	 { (char *)"Fl_Text_Buffer_swigregister", Fl_Text_Buffer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Style_Table_Entry", _wrap_new_Style_Table_Entry, METH_VARARGS, (char *)"new_Style_Table_Entry() -> Style_Table_Entry"},
	 { (char *)"delete_Style_Table_Entry", _wrap_delete_Style_Table_Entry, METH_VARARGS, (char *)"delete_Style_Table_Entry(Style_Table_Entry self)"},
	 { (char *)"Style_Table_Entry_swigregister", Style_Table_Entry_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Text_Display", _wrap_new_Fl_Text_Display, METH_VARARGS, (char *)"new_Fl_Text_Display(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Text_Display"},
	 { (char *)"delete_Fl_Text_Display", _wrap_delete_Fl_Text_Display, METH_VARARGS, (char *)"delete_Fl_Text_Display(Fl_Text_Display self)"},
	 { (char *)"Fl_Text_Display_handle", _wrap_Fl_Text_Display_handle, METH_VARARGS, (char *)"Fl_Text_Display_handle(Fl_Text_Display self, int e) -> int"},
	 { (char *)"Fl_Text_Display_buffer", _wrap_Fl_Text_Display_buffer, METH_VARARGS, (char *)"\n"
		"buffer(Fl_Text_Buffer buf)\n"
		"Fl_Text_Display_buffer(Fl_Text_Display self) -> Fl_Text_Buffer\n"
		""},
	 { (char *)"Fl_Text_Display_redisplay_range", _wrap_Fl_Text_Display_redisplay_range, METH_VARARGS, (char *)"Fl_Text_Display_redisplay_range(Fl_Text_Display self, int start, int end)"},
	 { (char *)"Fl_Text_Display_scroll", _wrap_Fl_Text_Display_scroll, METH_VARARGS, (char *)"Fl_Text_Display_scroll(Fl_Text_Display self, int topLineNum, int horizOffset)"},
	 { (char *)"Fl_Text_Display_insert", _wrap_Fl_Text_Display_insert, METH_VARARGS, (char *)"Fl_Text_Display_insert(Fl_Text_Display self, char const * text)"},
	 { (char *)"Fl_Text_Display_overstrike", _wrap_Fl_Text_Display_overstrike, METH_VARARGS, (char *)"Fl_Text_Display_overstrike(Fl_Text_Display self, char const * text)"},
	 { (char *)"Fl_Text_Display_insert_position", _wrap_Fl_Text_Display_insert_position, METH_VARARGS, (char *)"\n"
		"insert_position(int newPos)\n"
		"Fl_Text_Display_insert_position(Fl_Text_Display self) -> int\n"
		""},
	 { (char *)"Fl_Text_Display_position_to_xy", _wrap_Fl_Text_Display_position_to_xy, METH_VARARGS, (char *)"Fl_Text_Display_position_to_xy(Fl_Text_Display self, int pos, int * x, int * y) -> int"},
	 { (char *)"Fl_Text_Display_in_selection", _wrap_Fl_Text_Display_in_selection, METH_VARARGS, (char *)"Fl_Text_Display_in_selection(Fl_Text_Display self, int x, int y) -> int"},
	 { (char *)"Fl_Text_Display_show_insert_position", _wrap_Fl_Text_Display_show_insert_position, METH_VARARGS, (char *)"Fl_Text_Display_show_insert_position(Fl_Text_Display self)"},
	 { (char *)"Fl_Text_Display_move_right", _wrap_Fl_Text_Display_move_right, METH_VARARGS, (char *)"Fl_Text_Display_move_right(Fl_Text_Display self) -> int"},
	 { (char *)"Fl_Text_Display_move_left", _wrap_Fl_Text_Display_move_left, METH_VARARGS, (char *)"Fl_Text_Display_move_left(Fl_Text_Display self) -> int"},
	 { (char *)"Fl_Text_Display_move_up", _wrap_Fl_Text_Display_move_up, METH_VARARGS, (char *)"Fl_Text_Display_move_up(Fl_Text_Display self) -> int"},
	 { (char *)"Fl_Text_Display_move_down", _wrap_Fl_Text_Display_move_down, METH_VARARGS, (char *)"Fl_Text_Display_move_down(Fl_Text_Display self) -> int"},
	 { (char *)"Fl_Text_Display_count_lines", _wrap_Fl_Text_Display_count_lines, METH_VARARGS, (char *)"Fl_Text_Display_count_lines(Fl_Text_Display self, int start, int end, bool start_pos_is_line_start) -> int"},
	 { (char *)"Fl_Text_Display_line_start", _wrap_Fl_Text_Display_line_start, METH_VARARGS, (char *)"Fl_Text_Display_line_start(Fl_Text_Display self, int pos) -> int"},
	 { (char *)"Fl_Text_Display_line_end", _wrap_Fl_Text_Display_line_end, METH_VARARGS, (char *)"Fl_Text_Display_line_end(Fl_Text_Display self, int startPos, bool startPosIsLineStart) -> int"},
	 { (char *)"Fl_Text_Display_skip_lines", _wrap_Fl_Text_Display_skip_lines, METH_VARARGS, (char *)"Fl_Text_Display_skip_lines(Fl_Text_Display self, int startPos, int nLines, bool startPosIsLineStart) -> int"},
	 { (char *)"Fl_Text_Display_rewind_lines", _wrap_Fl_Text_Display_rewind_lines, METH_VARARGS, (char *)"Fl_Text_Display_rewind_lines(Fl_Text_Display self, int startPos, int nLines) -> int"},
	 { (char *)"Fl_Text_Display_next_word", _wrap_Fl_Text_Display_next_word, METH_VARARGS, (char *)"Fl_Text_Display_next_word(Fl_Text_Display self)"},
	 { (char *)"Fl_Text_Display_previous_word", _wrap_Fl_Text_Display_previous_word, METH_VARARGS, (char *)"Fl_Text_Display_previous_word(Fl_Text_Display self)"},
	 { (char *)"Fl_Text_Display_show_cursor", _wrap_Fl_Text_Display_show_cursor, METH_VARARGS, (char *)"Fl_Text_Display_show_cursor(Fl_Text_Display self, int b=1)"},
	 { (char *)"Fl_Text_Display_hide_cursor", _wrap_Fl_Text_Display_hide_cursor, METH_VARARGS, (char *)"Fl_Text_Display_hide_cursor(Fl_Text_Display self)"},
	 { (char *)"Fl_Text_Display_cursor_style", _wrap_Fl_Text_Display_cursor_style, METH_VARARGS, (char *)"Fl_Text_Display_cursor_style(Fl_Text_Display self, int style)"},
	 { (char *)"Fl_Text_Display_cursor_color", _wrap_Fl_Text_Display_cursor_color, METH_VARARGS, (char *)"\n"
		"cursor_color() -> Fl_Color\n"
		"Fl_Text_Display_cursor_color(Fl_Text_Display self, Fl_Color n)\n"
		""},
	 { (char *)"Fl_Text_Display_scrollbar_width", _wrap_Fl_Text_Display_scrollbar_width, METH_VARARGS, (char *)"\n"
		"scrollbar_width() -> int\n"
		"Fl_Text_Display_scrollbar_width(Fl_Text_Display self, int W)\n"
		""},
	 { (char *)"Fl_Text_Display_scrollbar_align", _wrap_Fl_Text_Display_scrollbar_align, METH_VARARGS, (char *)"\n"
		"scrollbar_align() -> Fl_Align\n"
		"Fl_Text_Display_scrollbar_align(Fl_Text_Display self, Fl_Align a)\n"
		""},
	 { (char *)"Fl_Text_Display_word_start", _wrap_Fl_Text_Display_word_start, METH_VARARGS, (char *)"Fl_Text_Display_word_start(Fl_Text_Display self, int pos) -> int"},
	 { (char *)"Fl_Text_Display_word_end", _wrap_Fl_Text_Display_word_end, METH_VARARGS, (char *)"Fl_Text_Display_word_end(Fl_Text_Display self, int pos) -> int"},
	 { (char *)"Fl_Text_Display_position_style", _wrap_Fl_Text_Display_position_style, METH_VARARGS, (char *)"Fl_Text_Display_position_style(Fl_Text_Display self, int lineStartPos, int lineLen, int lineIndex) -> int"},
	 { (char *)"Fl_Text_Display_shortcut", _wrap_Fl_Text_Display_shortcut, METH_VARARGS, (char *)"\n"
		"shortcut() -> int\n"
		"Fl_Text_Display_shortcut(Fl_Text_Display self, int s)\n"
		""},
	 { (char *)"Fl_Text_Display_textfont", _wrap_Fl_Text_Display_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Text_Display_textfont(Fl_Text_Display self, Fl_Font s)\n"
		""},
	 { (char *)"Fl_Text_Display_textsize", _wrap_Fl_Text_Display_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Text_Display_textsize(Fl_Text_Display self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Text_Display_textcolor", _wrap_Fl_Text_Display_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Text_Display_textcolor(Fl_Text_Display self, Fl_Color n)\n"
		""},
	 { (char *)"Fl_Text_Display_wrapped_column", _wrap_Fl_Text_Display_wrapped_column, METH_VARARGS, (char *)"Fl_Text_Display_wrapped_column(Fl_Text_Display self, int row, int column) -> int"},
	 { (char *)"Fl_Text_Display_wrapped_row", _wrap_Fl_Text_Display_wrapped_row, METH_VARARGS, (char *)"Fl_Text_Display_wrapped_row(Fl_Text_Display self, int row) -> int"},
	 { (char *)"Fl_Text_Display_wrap_mode", _wrap_Fl_Text_Display_wrap_mode, METH_VARARGS, (char *)"Fl_Text_Display_wrap_mode(Fl_Text_Display self, int wrap, int wrap_margin)"},
	 { (char *)"Fl_Text_Display_resize", _wrap_Fl_Text_Display_resize, METH_VARARGS, (char *)"Fl_Text_Display_resize(Fl_Text_Display self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Text_Display_x_to_col", _wrap_Fl_Text_Display_x_to_col, METH_VARARGS, (char *)"Fl_Text_Display_x_to_col(Fl_Text_Display self, double x) -> double"},
	 { (char *)"Fl_Text_Display_col_to_x", _wrap_Fl_Text_Display_col_to_x, METH_VARARGS, (char *)"Fl_Text_Display_col_to_x(Fl_Text_Display self, double col) -> double"},
	 { (char *)"Fl_Text_Display_linenumber_width", _wrap_Fl_Text_Display_linenumber_width, METH_VARARGS, (char *)"\n"
		"linenumber_width(int width)\n"
		"Fl_Text_Display_linenumber_width(Fl_Text_Display self) -> int\n"
		""},
	 { (char *)"Fl_Text_Display_linenumber_font", _wrap_Fl_Text_Display_linenumber_font, METH_VARARGS, (char *)"\n"
		"linenumber_font(Fl_Font val)\n"
		"Fl_Text_Display_linenumber_font(Fl_Text_Display self) -> Fl_Font\n"
		""},
	 { (char *)"Fl_Text_Display_linenumber_size", _wrap_Fl_Text_Display_linenumber_size, METH_VARARGS, (char *)"\n"
		"linenumber_size(Fl_Fontsize val)\n"
		"Fl_Text_Display_linenumber_size(Fl_Text_Display self) -> Fl_Fontsize\n"
		""},
	 { (char *)"Fl_Text_Display_linenumber_fgcolor", _wrap_Fl_Text_Display_linenumber_fgcolor, METH_VARARGS, (char *)"\n"
		"linenumber_fgcolor(Fl_Color val)\n"
		"Fl_Text_Display_linenumber_fgcolor(Fl_Text_Display self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Text_Display_linenumber_bgcolor", _wrap_Fl_Text_Display_linenumber_bgcolor, METH_VARARGS, (char *)"\n"
		"linenumber_bgcolor(Fl_Color val)\n"
		"Fl_Text_Display_linenumber_bgcolor(Fl_Text_Display self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Text_Display_linenumber_align", _wrap_Fl_Text_Display_linenumber_align, METH_VARARGS, (char *)"\n"
		"linenumber_align(Fl_Align val)\n"
		"Fl_Text_Display_linenumber_align(Fl_Text_Display self) -> Fl_Align\n"
		""},
	 { (char *)"Fl_Text_Display_linenumber_format", _wrap_Fl_Text_Display_linenumber_format, METH_VARARGS, (char *)"\n"
		"linenumber_format(char const * val)\n"
		"Fl_Text_Display_linenumber_format(Fl_Text_Display self) -> char const *\n"
		""},
	 { (char *)"Fl_Text_Display_draw", _wrap_Fl_Text_Display_draw, METH_VARARGS, (char *)"Fl_Text_Display_draw(Fl_Text_Display self)"},
	 { (char *)"Fl_Text_Display_highlight_data", _wrap_Fl_Text_Display_highlight_data, METH_VARARGS, (char *)"\n"
		"Fl_Text_Display_highlight_data(Fl_Text_Display self, Fl_Text_Buffer styleBuffer, Fl_Text_Display::Style_Table_Entry const * styleTable, \n"
		"    int nStyles, char unfinishedStyle, PyObject * func, \n"
		"    PyObject * cbArg)\n"
		""},
	 { (char *)"disown_Fl_Text_Display", _wrap_disown_Fl_Text_Display, METH_VARARGS, NULL},
	 { (char *)"Fl_Text_Display_swigregister", Fl_Text_Display_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Text_Editor", _wrap_new_Fl_Text_Editor, METH_VARARGS, (char *)"new_Fl_Text_Editor(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Text_Editor"},
	 { (char *)"delete_Fl_Text_Editor", _wrap_delete_Fl_Text_Editor, METH_VARARGS, (char *)"delete_Fl_Text_Editor(Fl_Text_Editor self)"},
	 { (char *)"Fl_Text_Editor_handle", _wrap_Fl_Text_Editor_handle, METH_VARARGS, (char *)"Fl_Text_Editor_handle(Fl_Text_Editor self, int e) -> int"},
	 { (char *)"Fl_Text_Editor_insert_mode", _wrap_Fl_Text_Editor_insert_mode, METH_VARARGS, (char *)"\n"
		"insert_mode(int b)\n"
		"Fl_Text_Editor_insert_mode(Fl_Text_Editor self) -> int\n"
		""},
	 { (char *)"Fl_Text_Editor_add_key_binding", _wrap_Fl_Text_Editor_add_key_binding, METH_VARARGS, (char *)"Fl_Text_Editor_add_key_binding(Fl_Text_Editor self, int key, int state, Fl_Text_Editor::Key_Func f)"},
	 { (char *)"Fl_Text_Editor_remove_key_binding", _wrap_Fl_Text_Editor_remove_key_binding, METH_VARARGS, (char *)"Fl_Text_Editor_remove_key_binding(Fl_Text_Editor self, int key, int state)"},
	 { (char *)"Fl_Text_Editor_remove_all_key_bindings", _wrap_Fl_Text_Editor_remove_all_key_bindings, METH_VARARGS, (char *)"Fl_Text_Editor_remove_all_key_bindings(Fl_Text_Editor self)"},
	 { (char *)"Fl_Text_Editor_bound_key_function", _wrap_Fl_Text_Editor_bound_key_function, METH_VARARGS, (char *)"Fl_Text_Editor_bound_key_function(Fl_Text_Editor self, int key, int state) -> Fl_Text_Editor::Key_Func"},
	 { (char *)"Fl_Text_Editor_default_key_function", _wrap_Fl_Text_Editor_default_key_function, METH_VARARGS, (char *)"Fl_Text_Editor_default_key_function(Fl_Text_Editor self, Fl_Text_Editor::Key_Func f)"},
	 { (char *)"Fl_Text_Editor_kf_default", _wrap_Fl_Text_Editor_kf_default, METH_VARARGS, (char *)"Fl_Text_Editor_kf_default(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_ignore", _wrap_Fl_Text_Editor_kf_ignore, METH_VARARGS, (char *)"Fl_Text_Editor_kf_ignore(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_backspace", _wrap_Fl_Text_Editor_kf_backspace, METH_VARARGS, (char *)"Fl_Text_Editor_kf_backspace(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_enter", _wrap_Fl_Text_Editor_kf_enter, METH_VARARGS, (char *)"Fl_Text_Editor_kf_enter(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_move", _wrap_Fl_Text_Editor_kf_move, METH_VARARGS, (char *)"Fl_Text_Editor_kf_move(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_shift_move", _wrap_Fl_Text_Editor_kf_shift_move, METH_VARARGS, (char *)"Fl_Text_Editor_kf_shift_move(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_ctrl_move", _wrap_Fl_Text_Editor_kf_ctrl_move, METH_VARARGS, (char *)"Fl_Text_Editor_kf_ctrl_move(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_c_s_move", _wrap_Fl_Text_Editor_kf_c_s_move, METH_VARARGS, (char *)"Fl_Text_Editor_kf_c_s_move(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_meta_move", _wrap_Fl_Text_Editor_kf_meta_move, METH_VARARGS, (char *)"Fl_Text_Editor_kf_meta_move(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_m_s_move", _wrap_Fl_Text_Editor_kf_m_s_move, METH_VARARGS, (char *)"Fl_Text_Editor_kf_m_s_move(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_home", _wrap_Fl_Text_Editor_kf_home, METH_VARARGS, (char *)"Fl_Text_Editor_kf_home(int arg1, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_end", _wrap_Fl_Text_Editor_kf_end, METH_VARARGS, (char *)"Fl_Text_Editor_kf_end(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_left", _wrap_Fl_Text_Editor_kf_left, METH_VARARGS, (char *)"Fl_Text_Editor_kf_left(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_up", _wrap_Fl_Text_Editor_kf_up, METH_VARARGS, (char *)"Fl_Text_Editor_kf_up(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_right", _wrap_Fl_Text_Editor_kf_right, METH_VARARGS, (char *)"Fl_Text_Editor_kf_right(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_down", _wrap_Fl_Text_Editor_kf_down, METH_VARARGS, (char *)"Fl_Text_Editor_kf_down(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_page_up", _wrap_Fl_Text_Editor_kf_page_up, METH_VARARGS, (char *)"Fl_Text_Editor_kf_page_up(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_page_down", _wrap_Fl_Text_Editor_kf_page_down, METH_VARARGS, (char *)"Fl_Text_Editor_kf_page_down(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_insert", _wrap_Fl_Text_Editor_kf_insert, METH_VARARGS, (char *)"Fl_Text_Editor_kf_insert(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_delete", _wrap_Fl_Text_Editor_kf_delete, METH_VARARGS, (char *)"Fl_Text_Editor_kf_delete(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_copy", _wrap_Fl_Text_Editor_kf_copy, METH_VARARGS, (char *)"Fl_Text_Editor_kf_copy(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_cut", _wrap_Fl_Text_Editor_kf_cut, METH_VARARGS, (char *)"Fl_Text_Editor_kf_cut(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_paste", _wrap_Fl_Text_Editor_kf_paste, METH_VARARGS, (char *)"Fl_Text_Editor_kf_paste(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_select_all", _wrap_Fl_Text_Editor_kf_select_all, METH_VARARGS, (char *)"Fl_Text_Editor_kf_select_all(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"Fl_Text_Editor_kf_undo", _wrap_Fl_Text_Editor_kf_undo, METH_VARARGS, (char *)"Fl_Text_Editor_kf_undo(int c, Fl_Text_Editor e) -> int"},
	 { (char *)"disown_Fl_Text_Editor", _wrap_disown_Fl_Text_Editor, METH_VARARGS, NULL},
	 { (char *)"Fl_Text_Editor_draw", _wrap_Fl_Text_Editor_draw, METH_VARARGS, (char *)"Fl_Text_Editor_draw(Fl_Text_Editor self)"},
	 { (char *)"Fl_Text_Editor_swigregister", Fl_Text_Editor_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Tile_handle", _wrap_Fl_Tile_handle, METH_VARARGS, (char *)"Fl_Tile_handle(Fl_Tile self, int event) -> int"},
	 { (char *)"new_Fl_Tile", _wrap_new_Fl_Tile, METH_VARARGS, (char *)"new_Fl_Tile(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Tile"},
	 { (char *)"Fl_Tile_resize", _wrap_Fl_Tile_resize, METH_VARARGS, (char *)"Fl_Tile_resize(Fl_Tile self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Tile_position", _wrap_Fl_Tile_position, METH_VARARGS, (char *)"Fl_Tile_position(Fl_Tile self, int oldx, int oldy, int newx, int newy)"},
	 { (char *)"delete_Fl_Tile", _wrap_delete_Fl_Tile, METH_VARARGS, (char *)"delete_Fl_Tile(Fl_Tile self)"},
	 { (char *)"disown_Fl_Tile", _wrap_disown_Fl_Tile, METH_VARARGS, NULL},
	 { (char *)"Fl_Tile_draw", _wrap_Fl_Tile_draw, METH_VARARGS, (char *)"Fl_Tile_draw(Fl_Tile self)"},
	 { (char *)"Fl_Tile_swigregister", Fl_Tile_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Tiled_Image", _wrap_new_Fl_Tiled_Image, METH_VARARGS, (char *)"new_Fl_Tiled_Image(PyObject * self, Fl_Image i, int W=0, int H=0) -> Fl_Tiled_Image"},
	 { (char *)"delete_Fl_Tiled_Image", _wrap_delete_Fl_Tiled_Image, METH_VARARGS, (char *)"delete_Fl_Tiled_Image(Fl_Tiled_Image self)"},
	 { (char *)"Fl_Tiled_Image_copy", _wrap_Fl_Tiled_Image_copy, METH_VARARGS, (char *)"\n"
		"copy(int W, int H) -> Fl_Image\n"
		"Fl_Tiled_Image_copy(Fl_Tiled_Image self) -> Fl_Image\n"
		""},
	 { (char *)"Fl_Tiled_Image_color_average", _wrap_Fl_Tiled_Image_color_average, METH_VARARGS, (char *)"Fl_Tiled_Image_color_average(Fl_Tiled_Image self, Fl_Color c, float i)"},
	 { (char *)"Fl_Tiled_Image_desaturate", _wrap_Fl_Tiled_Image_desaturate, METH_VARARGS, (char *)"Fl_Tiled_Image_desaturate(Fl_Tiled_Image self)"},
	 { (char *)"Fl_Tiled_Image_draw", _wrap_Fl_Tiled_Image_draw, METH_VARARGS, (char *)"\n"
		"draw(int X, int Y, int W, int H, int cx, int cy)\n"
		"Fl_Tiled_Image_draw(Fl_Tiled_Image self, int X, int Y)\n"
		""},
	 { (char *)"Fl_Tiled_Image_image", _wrap_Fl_Tiled_Image_image, METH_VARARGS, (char *)"Fl_Tiled_Image_image(Fl_Tiled_Image self) -> Fl_Image"},
	 { (char *)"disown_Fl_Tiled_Image", _wrap_disown_Fl_Tiled_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_Tiled_Image_swigregister", Fl_Tiled_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Timer_draw", _wrap_Fl_Timer_draw, METH_VARARGS, (char *)"Fl_Timer_draw(Fl_Timer self)"},
	 { (char *)"Fl_Timer_handle", _wrap_Fl_Timer_handle, METH_VARARGS, (char *)"Fl_Timer_handle(Fl_Timer self, int arg0) -> int"},
	 { (char *)"new_Fl_Timer", _wrap_new_Fl_Timer, METH_VARARGS, (char *)"new_Fl_Timer(PyObject * self, uchar t, int x, int y, int w, int h, char const * l) -> Fl_Timer"},
	 { (char *)"delete_Fl_Timer", _wrap_delete_Fl_Timer, METH_VARARGS, (char *)"delete_Fl_Timer(Fl_Timer self)"},
	 { (char *)"Fl_Timer_value", _wrap_Fl_Timer_value, METH_VARARGS, (char *)"\n"
		"value(double arg2)\n"
		"Fl_Timer_value(Fl_Timer self) -> double\n"
		""},
	 { (char *)"Fl_Timer_direction", _wrap_Fl_Timer_direction, METH_VARARGS, (char *)"\n"
		"direction() -> char\n"
		"Fl_Timer_direction(Fl_Timer self, char d)\n"
		""},
	 { (char *)"Fl_Timer_suspended", _wrap_Fl_Timer_suspended, METH_VARARGS, (char *)"\n"
		"suspended() -> char\n"
		"Fl_Timer_suspended(Fl_Timer self, char d)\n"
		""},
	 { (char *)"disown_Fl_Timer", _wrap_disown_Fl_Timer, METH_VARARGS, NULL},
	 { (char *)"Fl_Timer_swigregister", Fl_Timer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Toggle_Button", _wrap_new_Fl_Toggle_Button, METH_VARARGS, (char *)"new_Fl_Toggle_Button(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Toggle_Button"},
	 { (char *)"delete_Fl_Toggle_Button", _wrap_delete_Fl_Toggle_Button, METH_VARARGS, (char *)"delete_Fl_Toggle_Button(Fl_Toggle_Button self)"},
	 { (char *)"disown_Fl_Toggle_Button", _wrap_disown_Fl_Toggle_Button, METH_VARARGS, NULL},
	 { (char *)"Fl_Toggle_Button_draw", _wrap_Fl_Toggle_Button_draw, METH_VARARGS, (char *)"Fl_Toggle_Button_draw(Fl_Toggle_Button self)"},
	 { (char *)"Fl_Toggle_Button_swigregister", Fl_Toggle_Button_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Tooltip_delay", _wrap_Fl_Tooltip_delay, METH_VARARGS, (char *)"\n"
		"delay() -> float\n"
		"Fl_Tooltip_delay(float f)\n"
		""},
	 { (char *)"Fl_Tooltip_hoverdelay", _wrap_Fl_Tooltip_hoverdelay, METH_VARARGS, (char *)"\n"
		"hoverdelay() -> float\n"
		"Fl_Tooltip_hoverdelay(float f)\n"
		""},
	 { (char *)"Fl_Tooltip_enabled", _wrap_Fl_Tooltip_enabled, METH_VARARGS, (char *)"Fl_Tooltip_enabled() -> int"},
	 { (char *)"Fl_Tooltip_enable", _wrap_Fl_Tooltip_enable, METH_VARARGS, (char *)"Fl_Tooltip_enable(int b=1)"},
	 { (char *)"Fl_Tooltip_disable", _wrap_Fl_Tooltip_disable, METH_VARARGS, (char *)"Fl_Tooltip_disable()"},
	 { (char *)"Fl_Tooltip_enter_area", _wrap_Fl_Tooltip_enter_area, METH_VARARGS, (char *)"Fl_Tooltip_enter_area(Fl_Widget w, int X, int Y, int W, int H, char const * tip)"},
	 { (char *)"Fl_Tooltip_current", _wrap_Fl_Tooltip_current, METH_VARARGS, (char *)"\n"
		"current() -> Fl_Widget\n"
		"Fl_Tooltip_current(Fl_Widget arg1)\n"
		""},
	 { (char *)"Fl_Tooltip_font", _wrap_Fl_Tooltip_font, METH_VARARGS, (char *)"\n"
		"font() -> Fl_Font\n"
		"Fl_Tooltip_font(Fl_Font i)\n"
		""},
	 { (char *)"Fl_Tooltip_size", _wrap_Fl_Tooltip_size, METH_VARARGS, (char *)"\n"
		"size() -> Fl_Fontsize\n"
		"Fl_Tooltip_size(Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Tooltip_color", _wrap_Fl_Tooltip_color, METH_VARARGS, (char *)"\n"
		"color() -> Fl_Color\n"
		"Fl_Tooltip_color(Fl_Color c)\n"
		""},
	 { (char *)"Fl_Tooltip_textcolor", _wrap_Fl_Tooltip_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Tooltip_textcolor(Fl_Color c)\n"
		""},
	 { (char *)"Fl_Tooltip_margin_width", _wrap_Fl_Tooltip_margin_width, METH_VARARGS, (char *)"Fl_Tooltip_margin_width() -> int"},
	 { (char *)"Fl_Tooltip_margin_height", _wrap_Fl_Tooltip_margin_height, METH_VARARGS, (char *)"Fl_Tooltip_margin_height() -> int"},
	 { (char *)"Fl_Tooltip_wrap_width", _wrap_Fl_Tooltip_wrap_width, METH_VARARGS, (char *)"Fl_Tooltip_wrap_width() -> int"},
	 { (char *)"new_Fl_Tooltip", _wrap_new_Fl_Tooltip, METH_VARARGS, (char *)"new_Fl_Tooltip() -> Fl_Tooltip"},
	 { (char *)"delete_Fl_Tooltip", _wrap_delete_Fl_Tooltip, METH_VARARGS, (char *)"delete_Fl_Tooltip(Fl_Tooltip self)"},
	 { (char *)"Fl_Tooltip_swigregister", Fl_Tooltip_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Value_Output_draw", _wrap_Fl_Value_Output_draw, METH_VARARGS, (char *)"Fl_Value_Output_draw(Fl_Value_Output self)"},
	 { (char *)"Fl_Value_Output_handle", _wrap_Fl_Value_Output_handle, METH_VARARGS, (char *)"Fl_Value_Output_handle(Fl_Value_Output self, int arg0) -> int"},
	 { (char *)"new_Fl_Value_Output", _wrap_new_Fl_Value_Output, METH_VARARGS, (char *)"new_Fl_Value_Output(PyObject * self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Output"},
	 { (char *)"Fl_Value_Output_soft", _wrap_Fl_Value_Output_soft, METH_VARARGS, (char *)"\n"
		"soft(uchar s)\n"
		"Fl_Value_Output_soft(Fl_Value_Output self) -> uchar\n"
		""},
	 { (char *)"Fl_Value_Output_textfont", _wrap_Fl_Value_Output_textfont, METH_VARARGS, (char *)"\n"
		"textfont() -> Fl_Font\n"
		"Fl_Value_Output_textfont(Fl_Value_Output self, Fl_Font s)\n"
		""},
	 { (char *)"Fl_Value_Output_textsize", _wrap_Fl_Value_Output_textsize, METH_VARARGS, (char *)"\n"
		"textsize() -> Fl_Fontsize\n"
		"Fl_Value_Output_textsize(Fl_Value_Output self, Fl_Fontsize s)\n"
		""},
	 { (char *)"Fl_Value_Output_textcolor", _wrap_Fl_Value_Output_textcolor, METH_VARARGS, (char *)"\n"
		"textcolor() -> Fl_Color\n"
		"Fl_Value_Output_textcolor(Fl_Value_Output self, Fl_Color s)\n"
		""},
	 { (char *)"delete_Fl_Value_Output", _wrap_delete_Fl_Value_Output, METH_VARARGS, (char *)"delete_Fl_Value_Output(Fl_Value_Output self)"},
	 { (char *)"disown_Fl_Value_Output", _wrap_disown_Fl_Value_Output, METH_VARARGS, NULL},
	 { (char *)"Fl_Value_Output_swigregister", Fl_Value_Output_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Wizard", _wrap_new_Fl_Wizard, METH_VARARGS, (char *)"new_Fl_Wizard(PyObject * self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Wizard"},
	 { (char *)"Fl_Wizard_next", _wrap_Fl_Wizard_next, METH_VARARGS, (char *)"Fl_Wizard_next(Fl_Wizard self)"},
	 { (char *)"Fl_Wizard_prev", _wrap_Fl_Wizard_prev, METH_VARARGS, (char *)"Fl_Wizard_prev(Fl_Wizard self)"},
	 { (char *)"Fl_Wizard_value", _wrap_Fl_Wizard_value, METH_VARARGS, (char *)"\n"
		"value() -> Fl_Widget\n"
		"Fl_Wizard_value(Fl_Wizard self, Fl_Widget arg2)\n"
		""},
	 { (char *)"delete_Fl_Wizard", _wrap_delete_Fl_Wizard, METH_VARARGS, (char *)"delete_Fl_Wizard(Fl_Wizard self)"},
	 { (char *)"disown_Fl_Wizard", _wrap_disown_Fl_Wizard, METH_VARARGS, NULL},
	 { (char *)"Fl_Wizard_draw", _wrap_Fl_Wizard_draw, METH_VARARGS, (char *)"Fl_Wizard_draw(Fl_Wizard self)"},
	 { (char *)"Fl_Wizard_swigregister", Fl_Wizard_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_XBM_Image", _wrap_new_Fl_XBM_Image, METH_VARARGS, (char *)"new_Fl_XBM_Image(PyObject * self, char const * filename) -> Fl_XBM_Image"},
	 { (char *)"delete_Fl_XBM_Image", _wrap_delete_Fl_XBM_Image, METH_VARARGS, (char *)"delete_Fl_XBM_Image(Fl_XBM_Image self)"},
	 { (char *)"disown_Fl_XBM_Image", _wrap_disown_Fl_XBM_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_XBM_Image_swigregister", Fl_XBM_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_XPM_Image", _wrap_new_Fl_XPM_Image, METH_VARARGS, (char *)"new_Fl_XPM_Image(PyObject * self, char const * filename) -> Fl_XPM_Image"},
	 { (char *)"delete_Fl_XPM_Image", _wrap_delete_Fl_XPM_Image, METH_VARARGS, (char *)"delete_Fl_XPM_Image(Fl_XPM_Image self)"},
	 { (char *)"disown_Fl_XPM_Image", _wrap_disown_Fl_XPM_Image, METH_VARARGS, NULL},
	 { (char *)"Fl_XPM_Image_swigregister", Fl_XPM_Image_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Tree_Prefs", _wrap_new_Fl_Tree_Prefs, METH_VARARGS, (char *)"new_Fl_Tree_Prefs() -> Fl_Tree_Prefs"},
	 { (char *)"Fl_Tree_Prefs_item_labelfont", _wrap_Fl_Tree_Prefs_item_labelfont, METH_VARARGS, (char *)"\n"
		"item_labelfont() -> Fl_Font\n"
		"Fl_Tree_Prefs_item_labelfont(Fl_Tree_Prefs self, Fl_Font val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_item_labelsize", _wrap_Fl_Tree_Prefs_item_labelsize, METH_VARARGS, (char *)"\n"
		"item_labelsize() -> Fl_Fontsize\n"
		"Fl_Tree_Prefs_item_labelsize(Fl_Tree_Prefs self, Fl_Fontsize val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_item_labelfgcolor", _wrap_Fl_Tree_Prefs_item_labelfgcolor, METH_VARARGS, (char *)"\n"
		"item_labelfgcolor() -> Fl_Color\n"
		"Fl_Tree_Prefs_item_labelfgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_item_labelbgcolor", _wrap_Fl_Tree_Prefs_item_labelbgcolor, METH_VARARGS, (char *)"\n"
		"item_labelbgcolor() -> Fl_Color\n"
		"Fl_Tree_Prefs_item_labelbgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_labelfont", _wrap_Fl_Tree_Prefs_labelfont, METH_VARARGS, (char *)"\n"
		"labelfont() -> Fl_Font\n"
		"Fl_Tree_Prefs_labelfont(Fl_Tree_Prefs self, Fl_Font val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_labelsize", _wrap_Fl_Tree_Prefs_labelsize, METH_VARARGS, (char *)"\n"
		"labelsize() -> Fl_Fontsize\n"
		"Fl_Tree_Prefs_labelsize(Fl_Tree_Prefs self, Fl_Fontsize val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_labelfgcolor", _wrap_Fl_Tree_Prefs_labelfgcolor, METH_VARARGS, (char *)"\n"
		"labelfgcolor() -> Fl_Color\n"
		"Fl_Tree_Prefs_labelfgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_labelbgcolor", _wrap_Fl_Tree_Prefs_labelbgcolor, METH_VARARGS, (char *)"\n"
		"labelbgcolor() -> Fl_Color\n"
		"Fl_Tree_Prefs_labelbgcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_marginleft", _wrap_Fl_Tree_Prefs_marginleft, METH_VARARGS, (char *)"\n"
		"marginleft() -> int\n"
		"Fl_Tree_Prefs_marginleft(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_margintop", _wrap_Fl_Tree_Prefs_margintop, METH_VARARGS, (char *)"\n"
		"margintop() -> int\n"
		"Fl_Tree_Prefs_margintop(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_openchild_marginbottom", _wrap_Fl_Tree_Prefs_openchild_marginbottom, METH_VARARGS, (char *)"\n"
		"openchild_marginbottom() -> int\n"
		"Fl_Tree_Prefs_openchild_marginbottom(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_usericonmarginleft", _wrap_Fl_Tree_Prefs_usericonmarginleft, METH_VARARGS, (char *)"\n"
		"usericonmarginleft() -> int\n"
		"Fl_Tree_Prefs_usericonmarginleft(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_labelmarginleft", _wrap_Fl_Tree_Prefs_labelmarginleft, METH_VARARGS, (char *)"\n"
		"labelmarginleft() -> int\n"
		"Fl_Tree_Prefs_labelmarginleft(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_linespacing", _wrap_Fl_Tree_Prefs_linespacing, METH_VARARGS, (char *)"\n"
		"linespacing() -> int\n"
		"Fl_Tree_Prefs_linespacing(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_connectorcolor", _wrap_Fl_Tree_Prefs_connectorcolor, METH_VARARGS, (char *)"\n"
		"connectorcolor() -> Fl_Color\n"
		"Fl_Tree_Prefs_connectorcolor(Fl_Tree_Prefs self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_connectorstyle", _wrap_Fl_Tree_Prefs_connectorstyle, METH_VARARGS, (char *)"\n"
		"connectorstyle() -> Fl_Tree_Connector\n"
		"connectorstyle(Fl_Tree_Connector val)\n"
		"Fl_Tree_Prefs_connectorstyle(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_connectorwidth", _wrap_Fl_Tree_Prefs_connectorwidth, METH_VARARGS, (char *)"\n"
		"connectorwidth() -> int\n"
		"Fl_Tree_Prefs_connectorwidth(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_openicon", _wrap_Fl_Tree_Prefs_openicon, METH_VARARGS, (char *)"\n"
		"openicon() -> Fl_Image\n"
		"Fl_Tree_Prefs_openicon(Fl_Tree_Prefs self, Fl_Image val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_closeicon", _wrap_Fl_Tree_Prefs_closeicon, METH_VARARGS, (char *)"\n"
		"closeicon() -> Fl_Image\n"
		"Fl_Tree_Prefs_closeicon(Fl_Tree_Prefs self, Fl_Image val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_usericon", _wrap_Fl_Tree_Prefs_usericon, METH_VARARGS, (char *)"\n"
		"usericon() -> Fl_Image\n"
		"Fl_Tree_Prefs_usericon(Fl_Tree_Prefs self, Fl_Image val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_showcollapse", _wrap_Fl_Tree_Prefs_showcollapse, METH_VARARGS, (char *)"\n"
		"showcollapse() -> char\n"
		"Fl_Tree_Prefs_showcollapse(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_sortorder", _wrap_Fl_Tree_Prefs_sortorder, METH_VARARGS, (char *)"\n"
		"sortorder() -> Fl_Tree_Sort\n"
		"Fl_Tree_Prefs_sortorder(Fl_Tree_Prefs self, Fl_Tree_Sort val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_selectbox", _wrap_Fl_Tree_Prefs_selectbox, METH_VARARGS, (char *)"\n"
		"selectbox() -> Fl_Boxtype\n"
		"Fl_Tree_Prefs_selectbox(Fl_Tree_Prefs self, Fl_Boxtype val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_showroot", _wrap_Fl_Tree_Prefs_showroot, METH_VARARGS, (char *)"\n"
		"showroot() -> int\n"
		"Fl_Tree_Prefs_showroot(Fl_Tree_Prefs self, int val)\n"
		""},
	 { (char *)"Fl_Tree_Prefs_selectmode", _wrap_Fl_Tree_Prefs_selectmode, METH_VARARGS, (char *)"\n"
		"selectmode() -> Fl_Tree_Select\n"
		"Fl_Tree_Prefs_selectmode(Fl_Tree_Prefs self, Fl_Tree_Select val)\n"
		""},
	 { (char *)"delete_Fl_Tree_Prefs", _wrap_delete_Fl_Tree_Prefs, METH_VARARGS, (char *)"delete_Fl_Tree_Prefs(Fl_Tree_Prefs self)"},
	 { (char *)"Fl_Tree_Prefs_swigregister", Fl_Tree_Prefs_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Fl_Tree_Item_Array", _wrap_delete_Fl_Tree_Item_Array, METH_VARARGS, (char *)"delete_Fl_Tree_Item_Array(Fl_Tree_Item_Array self)"},
	 { (char *)"new_Fl_Tree_Item_Array", _wrap_new_Fl_Tree_Item_Array, METH_VARARGS, (char *)"\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"
		""},
	 { (char *)"Fl_Tree_Item_Array_total", _wrap_Fl_Tree_Item_Array_total, METH_VARARGS, (char *)"Fl_Tree_Item_Array_total(Fl_Tree_Item_Array self) -> int"},
	 { (char *)"Fl_Tree_Item_Array_swap", _wrap_Fl_Tree_Item_Array_swap, METH_VARARGS, (char *)"Fl_Tree_Item_Array_swap(Fl_Tree_Item_Array self, int ax, int bx)"},
	 { (char *)"Fl_Tree_Item_Array_move", _wrap_Fl_Tree_Item_Array_move, METH_VARARGS, (char *)"Fl_Tree_Item_Array_move(Fl_Tree_Item_Array self, int to, int _from) -> int"},
	 { (char *)"Fl_Tree_Item_Array_deparent", _wrap_Fl_Tree_Item_Array_deparent, METH_VARARGS, (char *)"Fl_Tree_Item_Array_deparent(Fl_Tree_Item_Array self, int pos) -> int"},
	 { (char *)"Fl_Tree_Item_Array_reparent", _wrap_Fl_Tree_Item_Array_reparent, METH_VARARGS, (char *)"Fl_Tree_Item_Array_reparent(Fl_Tree_Item_Array self, Fl_Tree_Item item, Fl_Tree_Item newparent, int pos) -> int"},
	 { (char *)"Fl_Tree_Item_Array_clear", _wrap_Fl_Tree_Item_Array_clear, METH_VARARGS, (char *)"Fl_Tree_Item_Array_clear(Fl_Tree_Item_Array self)"},
	 { (char *)"Fl_Tree_Item_Array_add", _wrap_Fl_Tree_Item_Array_add, METH_VARARGS, (char *)"Fl_Tree_Item_Array_add(Fl_Tree_Item_Array self, Fl_Tree_Item val)"},
	 { (char *)"Fl_Tree_Item_Array_insert", _wrap_Fl_Tree_Item_Array_insert, METH_VARARGS, (char *)"Fl_Tree_Item_Array_insert(Fl_Tree_Item_Array self, int pos, Fl_Tree_Item new_item)"},
	 { (char *)"Fl_Tree_Item_Array_replace", _wrap_Fl_Tree_Item_Array_replace, METH_VARARGS, (char *)"Fl_Tree_Item_Array_replace(Fl_Tree_Item_Array self, int pos, Fl_Tree_Item new_item)"},
	 { (char *)"Fl_Tree_Item_Array_remove", _wrap_Fl_Tree_Item_Array_remove, METH_VARARGS, (char *)"\n"
		"remove(int index)\n"
		"Fl_Tree_Item_Array_remove(Fl_Tree_Item_Array self, Fl_Tree_Item item) -> int\n"
		""},
	 { (char *)"Fl_Tree_Item_Array_swigregister", Fl_Tree_Item_Array_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Fl_Tree_Item", _wrap_delete_Fl_Tree_Item, METH_VARARGS, (char *)"delete_Fl_Tree_Item(Fl_Tree_Item self)"},
	 { (char *)"new_Fl_Tree_Item", _wrap_new_Fl_Tree_Item, METH_VARARGS, (char *)"\n"
		"Fl_Tree_Item(Fl_Tree_Prefs prefs)\n"
		"new_Fl_Tree_Item(Fl_Tree_Item o) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_Item_x", _wrap_Fl_Tree_Item_x, METH_VARARGS, (char *)"Fl_Tree_Item_x(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_y", _wrap_Fl_Tree_Item_y, METH_VARARGS, (char *)"Fl_Tree_Item_y(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_w", _wrap_Fl_Tree_Item_w, METH_VARARGS, (char *)"Fl_Tree_Item_w(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_h", _wrap_Fl_Tree_Item_h, METH_VARARGS, (char *)"Fl_Tree_Item_h(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_label_x", _wrap_Fl_Tree_Item_label_x, METH_VARARGS, (char *)"Fl_Tree_Item_label_x(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_label_y", _wrap_Fl_Tree_Item_label_y, METH_VARARGS, (char *)"Fl_Tree_Item_label_y(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_label_w", _wrap_Fl_Tree_Item_label_w, METH_VARARGS, (char *)"Fl_Tree_Item_label_w(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_label_h", _wrap_Fl_Tree_Item_label_h, METH_VARARGS, (char *)"Fl_Tree_Item_label_h(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_draw", _wrap_Fl_Tree_Item_draw, METH_VARARGS, (char *)"\n"
		"Fl_Tree_Item_draw(Fl_Tree_Item self, int X, int W, Fl_Widget tree, Fl_Tree_Item itemfocus, Fl_Tree_Prefs prefs, \n"
		"    int lastchild=1)\n"
		""},
	 { (char *)"Fl_Tree_Item_show_self", _wrap_Fl_Tree_Item_show_self, METH_VARARGS, (char *)"Fl_Tree_Item_show_self(Fl_Tree_Item self, char const * indent=\"\")"},
	 { (char *)"Fl_Tree_Item_label", _wrap_Fl_Tree_Item_label, METH_VARARGS, (char *)"\n"
		"label(char const * val)\n"
		"Fl_Tree_Item_label(Fl_Tree_Item self) -> char const *\n"
		""},
	 { (char *)"Fl_Tree_Item_user_data", _wrap_Fl_Tree_Item_user_data, METH_VARARGS, (char *)"\n"
		"user_data(void * data)\n"
		"Fl_Tree_Item_user_data(Fl_Tree_Item self) -> void *\n"
		""},
	 { (char *)"Fl_Tree_Item_labelfont", _wrap_Fl_Tree_Item_labelfont, METH_VARARGS, (char *)"\n"
		"labelfont(Fl_Font val)\n"
		"Fl_Tree_Item_labelfont(Fl_Tree_Item self) -> Fl_Font\n"
		""},
	 { (char *)"Fl_Tree_Item_labelsize", _wrap_Fl_Tree_Item_labelsize, METH_VARARGS, (char *)"\n"
		"labelsize(Fl_Fontsize val)\n"
		"Fl_Tree_Item_labelsize(Fl_Tree_Item self) -> Fl_Fontsize\n"
		""},
	 { (char *)"Fl_Tree_Item_labelfgcolor", _wrap_Fl_Tree_Item_labelfgcolor, METH_VARARGS, (char *)"\n"
		"labelfgcolor(Fl_Color val)\n"
		"Fl_Tree_Item_labelfgcolor(Fl_Tree_Item self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Tree_Item_labelcolor", _wrap_Fl_Tree_Item_labelcolor, METH_VARARGS, (char *)"\n"
		"labelcolor(Fl_Color val)\n"
		"Fl_Tree_Item_labelcolor(Fl_Tree_Item self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Tree_Item_labelbgcolor", _wrap_Fl_Tree_Item_labelbgcolor, METH_VARARGS, (char *)"\n"
		"labelbgcolor(Fl_Color val)\n"
		"Fl_Tree_Item_labelbgcolor(Fl_Tree_Item self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Tree_Item_widget", _wrap_Fl_Tree_Item_widget, METH_VARARGS, (char *)"\n"
		"widget(Fl_Widget val)\n"
		"Fl_Tree_Item_widget(Fl_Tree_Item self) -> Fl_Widget\n"
		""},
	 { (char *)"Fl_Tree_Item_children", _wrap_Fl_Tree_Item_children, METH_VARARGS, (char *)"Fl_Tree_Item_children(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_child", _wrap_Fl_Tree_Item_child, METH_VARARGS, (char *)"\n"
		"child(int index) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_child(Fl_Tree_Item self, int t) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_Item_has_children", _wrap_Fl_Tree_Item_has_children, METH_VARARGS, (char *)"Fl_Tree_Item_has_children(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_find_child", _wrap_Fl_Tree_Item_find_child, METH_VARARGS, (char *)"\n"
		"find_child(char const * name) -> int\n"
		"Fl_Tree_Item_find_child(Fl_Tree_Item self, Fl_Tree_Item item) -> int\n"
		""},
	 { (char *)"Fl_Tree_Item_remove_child", _wrap_Fl_Tree_Item_remove_child, METH_VARARGS, (char *)"\n"
		"remove_child(Fl_Tree_Item item) -> int\n"
		"Fl_Tree_Item_remove_child(Fl_Tree_Item self, char const * new_label) -> int\n"
		""},
	 { (char *)"Fl_Tree_Item_clear_children", _wrap_Fl_Tree_Item_clear_children, METH_VARARGS, (char *)"Fl_Tree_Item_clear_children(Fl_Tree_Item self)"},
	 { (char *)"Fl_Tree_Item_swap_children", _wrap_Fl_Tree_Item_swap_children, METH_VARARGS, (char *)"\n"
		"swap_children(int ax, int bx)\n"
		"Fl_Tree_Item_swap_children(Fl_Tree_Item self, Fl_Tree_Item a, Fl_Tree_Item b) -> int\n"
		""},
	 { (char *)"Fl_Tree_Item_find_child_item", _wrap_Fl_Tree_Item_find_child_item, METH_VARARGS, (char *)"\n"
		"find_child_item(char const * name) -> Fl_Tree_Item\n"
		"find_child_item(char const * name) -> Fl_Tree_Item\n"
		"find_child_item(char ** arr) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_child_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_Item_find_item", _wrap_Fl_Tree_Item_find_item, METH_VARARGS, (char *)"\n"
		"find_item(char ** arr) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_Item_add", _wrap_Fl_Tree_Item_add, METH_VARARGS, (char *)"\n"
		"add(Fl_Tree_Prefs prefs, char const * new_label, Fl_Tree_Item newitem) -> Fl_Tree_Item\n"
		"add(Fl_Tree_Prefs prefs, char const * new_label) -> Fl_Tree_Item\n"
		"add(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"
		""},
	 { (char *)"Fl_Tree_Item_insert", _wrap_Fl_Tree_Item_insert, METH_VARARGS, (char *)"Fl_Tree_Item_insert(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label, int pos=0) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_insert_above", _wrap_Fl_Tree_Item_insert_above, METH_VARARGS, (char *)"Fl_Tree_Item_insert_above(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_deparent", _wrap_Fl_Tree_Item_deparent, METH_VARARGS, (char *)"Fl_Tree_Item_deparent(Fl_Tree_Item self, int index) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_reparent", _wrap_Fl_Tree_Item_reparent, METH_VARARGS, (char *)"Fl_Tree_Item_reparent(Fl_Tree_Item self, Fl_Tree_Item newchild, int index) -> int"},
	 { (char *)"Fl_Tree_Item_move", _wrap_Fl_Tree_Item_move, METH_VARARGS, (char *)"\n"
		"move(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"
		""},
	 { (char *)"Fl_Tree_Item_move_above", _wrap_Fl_Tree_Item_move_above, METH_VARARGS, (char *)"Fl_Tree_Item_move_above(Fl_Tree_Item self, Fl_Tree_Item item) -> int"},
	 { (char *)"Fl_Tree_Item_move_below", _wrap_Fl_Tree_Item_move_below, METH_VARARGS, (char *)"Fl_Tree_Item_move_below(Fl_Tree_Item self, Fl_Tree_Item item) -> int"},
	 { (char *)"Fl_Tree_Item_move_into", _wrap_Fl_Tree_Item_move_into, METH_VARARGS, (char *)"Fl_Tree_Item_move_into(Fl_Tree_Item self, Fl_Tree_Item item, int pos=0) -> int"},
	 { (char *)"Fl_Tree_Item_depth", _wrap_Fl_Tree_Item_depth, METH_VARARGS, (char *)"Fl_Tree_Item_depth(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_prev", _wrap_Fl_Tree_Item_prev, METH_VARARGS, (char *)"Fl_Tree_Item_prev(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_next", _wrap_Fl_Tree_Item_next, METH_VARARGS, (char *)"Fl_Tree_Item_next(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_next_sibling", _wrap_Fl_Tree_Item_next_sibling, METH_VARARGS, (char *)"Fl_Tree_Item_next_sibling(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_prev_sibling", _wrap_Fl_Tree_Item_prev_sibling, METH_VARARGS, (char *)"Fl_Tree_Item_prev_sibling(Fl_Tree_Item self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_update_prev_next", _wrap_Fl_Tree_Item_update_prev_next, METH_VARARGS, (char *)"Fl_Tree_Item_update_prev_next(Fl_Tree_Item self, int index)"},
	 { (char *)"Fl_Tree_Item_next_displayed", _wrap_Fl_Tree_Item_next_displayed, METH_VARARGS, (char *)"Fl_Tree_Item_next_displayed(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_prev_displayed", _wrap_Fl_Tree_Item_prev_displayed, METH_VARARGS, (char *)"Fl_Tree_Item_prev_displayed(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_next_visible", _wrap_Fl_Tree_Item_next_visible, METH_VARARGS, (char *)"Fl_Tree_Item_next_visible(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_prev_visible", _wrap_Fl_Tree_Item_prev_visible, METH_VARARGS, (char *)"Fl_Tree_Item_prev_visible(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_Item_parent", _wrap_Fl_Tree_Item_parent, METH_VARARGS, (char *)"\n"
		"parent() -> Fl_Tree_Item\n"
		"parent() -> Fl_Tree_Item\n"
		"Fl_Tree_Item_parent(Fl_Tree_Item self, Fl_Tree_Item val)\n"
		""},
	 { (char *)"Fl_Tree_Item_open", _wrap_Fl_Tree_Item_open, METH_VARARGS, (char *)"Fl_Tree_Item_open(Fl_Tree_Item self)"},
	 { (char *)"Fl_Tree_Item_close", _wrap_Fl_Tree_Item_close, METH_VARARGS, (char *)"Fl_Tree_Item_close(Fl_Tree_Item self)"},
	 { (char *)"Fl_Tree_Item_is_open", _wrap_Fl_Tree_Item_is_open, METH_VARARGS, (char *)"Fl_Tree_Item_is_open(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_is_close", _wrap_Fl_Tree_Item_is_close, METH_VARARGS, (char *)"Fl_Tree_Item_is_close(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_open_toggle", _wrap_Fl_Tree_Item_open_toggle, METH_VARARGS, (char *)"Fl_Tree_Item_open_toggle(Fl_Tree_Item self)"},
	 { (char *)"Fl_Tree_Item_select", _wrap_Fl_Tree_Item_select, METH_VARARGS, (char *)"Fl_Tree_Item_select(Fl_Tree_Item self, int val=1)"},
	 { (char *)"Fl_Tree_Item_select_toggle", _wrap_Fl_Tree_Item_select_toggle, METH_VARARGS, (char *)"Fl_Tree_Item_select_toggle(Fl_Tree_Item self)"},
	 { (char *)"Fl_Tree_Item_select_all", _wrap_Fl_Tree_Item_select_all, METH_VARARGS, (char *)"Fl_Tree_Item_select_all(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_deselect", _wrap_Fl_Tree_Item_deselect, METH_VARARGS, (char *)"Fl_Tree_Item_deselect(Fl_Tree_Item self)"},
	 { (char *)"Fl_Tree_Item_deselect_all", _wrap_Fl_Tree_Item_deselect_all, METH_VARARGS, (char *)"Fl_Tree_Item_deselect_all(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_is_selected", _wrap_Fl_Tree_Item_is_selected, METH_VARARGS, (char *)"Fl_Tree_Item_is_selected(Fl_Tree_Item self) -> char"},
	 { (char *)"Fl_Tree_Item_activate", _wrap_Fl_Tree_Item_activate, METH_VARARGS, (char *)"Fl_Tree_Item_activate(Fl_Tree_Item self, int val=1)"},
	 { (char *)"Fl_Tree_Item_deactivate", _wrap_Fl_Tree_Item_deactivate, METH_VARARGS, (char *)"Fl_Tree_Item_deactivate(Fl_Tree_Item self)"},
	 { (char *)"Fl_Tree_Item_is_activated", _wrap_Fl_Tree_Item_is_activated, METH_VARARGS, (char *)"Fl_Tree_Item_is_activated(Fl_Tree_Item self) -> char"},
	 { (char *)"Fl_Tree_Item_is_active", _wrap_Fl_Tree_Item_is_active, METH_VARARGS, (char *)"Fl_Tree_Item_is_active(Fl_Tree_Item self) -> char"},
	 { (char *)"Fl_Tree_Item_visible", _wrap_Fl_Tree_Item_visible, METH_VARARGS, (char *)"Fl_Tree_Item_visible(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_is_visible", _wrap_Fl_Tree_Item_is_visible, METH_VARARGS, (char *)"Fl_Tree_Item_is_visible(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_visible_r", _wrap_Fl_Tree_Item_visible_r, METH_VARARGS, (char *)"Fl_Tree_Item_visible_r(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_usericon", _wrap_Fl_Tree_Item_usericon, METH_VARARGS, (char *)"\n"
		"usericon(Fl_Image val)\n"
		"Fl_Tree_Item_usericon(Fl_Tree_Item self) -> Fl_Image\n"
		""},
	 { (char *)"Fl_Tree_Item_find_clicked", _wrap_Fl_Tree_Item_find_clicked, METH_VARARGS, (char *)"\n"
		"find_clicked(Fl_Tree_Prefs prefs) -> Fl_Tree_Item\n"
		"Fl_Tree_Item_find_clicked(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_Item_event_on_collapse_icon", _wrap_Fl_Tree_Item_event_on_collapse_icon, METH_VARARGS, (char *)"Fl_Tree_Item_event_on_collapse_icon(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"},
	 { (char *)"Fl_Tree_Item_event_on_label", _wrap_Fl_Tree_Item_event_on_label, METH_VARARGS, (char *)"Fl_Tree_Item_event_on_label(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"},
	 { (char *)"Fl_Tree_Item_is_root", _wrap_Fl_Tree_Item_is_root, METH_VARARGS, (char *)"Fl_Tree_Item_is_root(Fl_Tree_Item self) -> int"},
	 { (char *)"Fl_Tree_Item_swigregister", Fl_Tree_Item_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Tree", _wrap_new_Fl_Tree, METH_VARARGS, (char *)"new_Fl_Tree(PyObject * self, int X, int Y, int W, int H, char const * L=None) -> Fl_Tree"},
	 { (char *)"delete_Fl_Tree", _wrap_delete_Fl_Tree, METH_VARARGS, (char *)"delete_Fl_Tree(Fl_Tree self)"},
	 { (char *)"Fl_Tree_handle", _wrap_Fl_Tree_handle, METH_VARARGS, (char *)"Fl_Tree_handle(Fl_Tree self, int e) -> int"},
	 { (char *)"Fl_Tree_draw", _wrap_Fl_Tree_draw, METH_VARARGS, (char *)"Fl_Tree_draw(Fl_Tree self)"},
	 { (char *)"Fl_Tree_show_self", _wrap_Fl_Tree_show_self, METH_VARARGS, (char *)"Fl_Tree_show_self(Fl_Tree self)"},
	 { (char *)"Fl_Tree_resize", _wrap_Fl_Tree_resize, METH_VARARGS, (char *)"Fl_Tree_resize(Fl_Tree self, int arg0, int arg1, int arg2, int arg3)"},
	 { (char *)"Fl_Tree_root_label", _wrap_Fl_Tree_root_label, METH_VARARGS, (char *)"Fl_Tree_root_label(Fl_Tree self, char const * new_label)"},
	 { (char *)"Fl_Tree_root", _wrap_Fl_Tree_root, METH_VARARGS, (char *)"\n"
		"root() -> Fl_Tree_Item\n"
		"Fl_Tree_root(Fl_Tree self, Fl_Tree_Item newitem)\n"
		""},
	 { (char *)"Fl_Tree_prefs", _wrap_Fl_Tree_prefs, METH_VARARGS, (char *)"Fl_Tree_prefs(Fl_Tree self) -> Fl_Tree_Prefs"},
	 { (char *)"Fl_Tree_add", _wrap_Fl_Tree_add, METH_VARARGS, (char *)"\n"
		"add(char const * path) -> Fl_Tree_Item\n"
		"add(char const * path, Fl_Tree_Item newitem) -> Fl_Tree_Item\n"
		"Fl_Tree_add(Fl_Tree self, Fl_Tree_Item parent_item, char const * name) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_insert_above", _wrap_Fl_Tree_insert_above, METH_VARARGS, (char *)"Fl_Tree_insert_above(Fl_Tree self, Fl_Tree_Item above, char const * name) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_insert", _wrap_Fl_Tree_insert, METH_VARARGS, (char *)"Fl_Tree_insert(Fl_Tree self, Fl_Tree_Item item, char const * name, int pos) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_remove", _wrap_Fl_Tree_remove, METH_VARARGS, (char *)"Fl_Tree_remove(Fl_Tree self, Fl_Tree_Item item) -> int"},
	 { (char *)"Fl_Tree_clear", _wrap_Fl_Tree_clear, METH_VARARGS, (char *)"Fl_Tree_clear(Fl_Tree self)"},
	 { (char *)"Fl_Tree_clear_children", _wrap_Fl_Tree_clear_children, METH_VARARGS, (char *)"Fl_Tree_clear_children(Fl_Tree self, Fl_Tree_Item item)"},
	 { (char *)"Fl_Tree_find_item", _wrap_Fl_Tree_find_item, METH_VARARGS, (char *)"\n"
		"find_item(char const * path) -> Fl_Tree_Item\n"
		"Fl_Tree_find_item(Fl_Tree self, char const * path) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_item_pathname", _wrap_Fl_Tree_item_pathname, METH_VARARGS, (char *)"Fl_Tree_item_pathname(Fl_Tree self, char * pathname, int pathnamelen, Fl_Tree_Item item) -> int"},
	 { (char *)"Fl_Tree_find_clicked", _wrap_Fl_Tree_find_clicked, METH_VARARGS, (char *)"\n"
		"find_clicked() -> Fl_Tree_Item\n"
		"Fl_Tree_find_clicked(Fl_Tree self) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_item_clicked", _wrap_Fl_Tree_item_clicked, METH_VARARGS, (char *)"Fl_Tree_item_clicked(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_first", _wrap_Fl_Tree_first, METH_VARARGS, (char *)"Fl_Tree_first(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_first_visible", _wrap_Fl_Tree_first_visible, METH_VARARGS, (char *)"Fl_Tree_first_visible(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_first_visible_item", _wrap_Fl_Tree_first_visible_item, METH_VARARGS, (char *)"Fl_Tree_first_visible_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_next", _wrap_Fl_Tree_next, METH_VARARGS, (char *)"Fl_Tree_next(Fl_Tree self, Fl_Tree_Item item=None) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_prev", _wrap_Fl_Tree_prev, METH_VARARGS, (char *)"Fl_Tree_prev(Fl_Tree self, Fl_Tree_Item item=None) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_last", _wrap_Fl_Tree_last, METH_VARARGS, (char *)"Fl_Tree_last(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_last_visible", _wrap_Fl_Tree_last_visible, METH_VARARGS, (char *)"Fl_Tree_last_visible(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_last_visible_item", _wrap_Fl_Tree_last_visible_item, METH_VARARGS, (char *)"Fl_Tree_last_visible_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_first_selected_item", _wrap_Fl_Tree_first_selected_item, METH_VARARGS, (char *)"Fl_Tree_first_selected_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_last_selected_item", _wrap_Fl_Tree_last_selected_item, METH_VARARGS, (char *)"Fl_Tree_last_selected_item(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_next_item", _wrap_Fl_Tree_next_item, METH_VARARGS, (char *)"Fl_Tree_next_item(Fl_Tree self, Fl_Tree_Item item, int dir=0xff54, bool visible=False) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_next_selected_item", _wrap_Fl_Tree_next_selected_item, METH_VARARGS, (char *)"\n"
		"next_selected_item(Fl_Tree_Item item=None) -> Fl_Tree_Item\n"
		"Fl_Tree_next_selected_item(Fl_Tree self, Fl_Tree_Item item, int dir) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_open", _wrap_Fl_Tree_open, METH_VARARGS, (char *)"\n"
		"open(Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_open(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { (char *)"Fl_Tree_open_toggle", _wrap_Fl_Tree_open_toggle, METH_VARARGS, (char *)"Fl_Tree_open_toggle(Fl_Tree self, Fl_Tree_Item item, int docallback=1)"},
	 { (char *)"Fl_Tree_close", _wrap_Fl_Tree_close, METH_VARARGS, (char *)"\n"
		"close(Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_close(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { (char *)"Fl_Tree_is_open", _wrap_Fl_Tree_is_open, METH_VARARGS, (char *)"\n"
		"is_open(Fl_Tree_Item item) -> int\n"
		"Fl_Tree_is_open(Fl_Tree self, char const * path) -> int\n"
		""},
	 { (char *)"Fl_Tree_is_close", _wrap_Fl_Tree_is_close, METH_VARARGS, (char *)"\n"
		"is_close(Fl_Tree_Item item) -> int\n"
		"Fl_Tree_is_close(Fl_Tree self, char const * path) -> int\n"
		""},
	 { (char *)"Fl_Tree_select", _wrap_Fl_Tree_select, METH_VARARGS, (char *)"\n"
		"select(Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_select(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { (char *)"Fl_Tree_select_toggle", _wrap_Fl_Tree_select_toggle, METH_VARARGS, (char *)"Fl_Tree_select_toggle(Fl_Tree self, Fl_Tree_Item item, int docallback=1)"},
	 { (char *)"Fl_Tree_deselect", _wrap_Fl_Tree_deselect, METH_VARARGS, (char *)"\n"
		"deselect(Fl_Tree_Item item, int docallback=1) -> int\n"
		"Fl_Tree_deselect(Fl_Tree self, char const * path, int docallback=1) -> int\n"
		""},
	 { (char *)"Fl_Tree_deselect_all", _wrap_Fl_Tree_deselect_all, METH_VARARGS, (char *)"Fl_Tree_deselect_all(Fl_Tree self, Fl_Tree_Item item=None, int docallback=1) -> int"},
	 { (char *)"Fl_Tree_select_only", _wrap_Fl_Tree_select_only, METH_VARARGS, (char *)"Fl_Tree_select_only(Fl_Tree self, Fl_Tree_Item selitem, int docallback=1) -> int"},
	 { (char *)"Fl_Tree_select_all", _wrap_Fl_Tree_select_all, METH_VARARGS, (char *)"Fl_Tree_select_all(Fl_Tree self, Fl_Tree_Item item=None, int docallback=1) -> int"},
	 { (char *)"Fl_Tree_extend_selection_dir", _wrap_Fl_Tree_extend_selection_dir, METH_VARARGS, (char *)"Fl_Tree_extend_selection_dir(Fl_Tree self, Fl_Tree_Item _from, Fl_Tree_Item to, int dir, int val, bool visible) -> int"},
	 { (char *)"Fl_Tree_set_item_focus", _wrap_Fl_Tree_set_item_focus, METH_VARARGS, (char *)"Fl_Tree_set_item_focus(Fl_Tree self, Fl_Tree_Item item)"},
	 { (char *)"Fl_Tree_get_item_focus", _wrap_Fl_Tree_get_item_focus, METH_VARARGS, (char *)"Fl_Tree_get_item_focus(Fl_Tree self) -> Fl_Tree_Item"},
	 { (char *)"Fl_Tree_is_selected", _wrap_Fl_Tree_is_selected, METH_VARARGS, (char *)"\n"
		"is_selected(Fl_Tree_Item item) -> int\n"
		"Fl_Tree_is_selected(Fl_Tree self, char const * path) -> int\n"
		""},
	 { (char *)"Fl_Tree_item_labelfont", _wrap_Fl_Tree_item_labelfont, METH_VARARGS, (char *)"\n"
		"item_labelfont() -> Fl_Font\n"
		"Fl_Tree_item_labelfont(Fl_Tree self, Fl_Font val)\n"
		""},
	 { (char *)"Fl_Tree_item_labelsize", _wrap_Fl_Tree_item_labelsize, METH_VARARGS, (char *)"\n"
		"item_labelsize() -> Fl_Fontsize\n"
		"Fl_Tree_item_labelsize(Fl_Tree self, Fl_Fontsize val)\n"
		""},
	 { (char *)"Fl_Tree_item_labelfgcolor", _wrap_Fl_Tree_item_labelfgcolor, METH_VARARGS, (char *)"\n"
		"item_labelfgcolor() -> Fl_Color\n"
		"Fl_Tree_item_labelfgcolor(Fl_Tree self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_item_labelbgcolor", _wrap_Fl_Tree_item_labelbgcolor, METH_VARARGS, (char *)"\n"
		"item_labelbgcolor() -> Fl_Color\n"
		"Fl_Tree_item_labelbgcolor(Fl_Tree self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_connectorcolor", _wrap_Fl_Tree_connectorcolor, METH_VARARGS, (char *)"\n"
		"connectorcolor() -> Fl_Color\n"
		"Fl_Tree_connectorcolor(Fl_Tree self, Fl_Color val)\n"
		""},
	 { (char *)"Fl_Tree_marginleft", _wrap_Fl_Tree_marginleft, METH_VARARGS, (char *)"\n"
		"marginleft() -> int\n"
		"Fl_Tree_marginleft(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_margintop", _wrap_Fl_Tree_margintop, METH_VARARGS, (char *)"\n"
		"margintop() -> int\n"
		"Fl_Tree_margintop(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_linespacing", _wrap_Fl_Tree_linespacing, METH_VARARGS, (char *)"\n"
		"linespacing() -> int\n"
		"Fl_Tree_linespacing(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_openchild_marginbottom", _wrap_Fl_Tree_openchild_marginbottom, METH_VARARGS, (char *)"\n"
		"openchild_marginbottom() -> int\n"
		"Fl_Tree_openchild_marginbottom(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_usericonmarginleft", _wrap_Fl_Tree_usericonmarginleft, METH_VARARGS, (char *)"\n"
		"usericonmarginleft() -> int\n"
		"Fl_Tree_usericonmarginleft(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_labelmarginleft", _wrap_Fl_Tree_labelmarginleft, METH_VARARGS, (char *)"\n"
		"labelmarginleft() -> int\n"
		"Fl_Tree_labelmarginleft(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_connectorwidth", _wrap_Fl_Tree_connectorwidth, METH_VARARGS, (char *)"\n"
		"connectorwidth() -> int\n"
		"Fl_Tree_connectorwidth(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_usericon", _wrap_Fl_Tree_usericon, METH_VARARGS, (char *)"\n"
		"usericon() -> Fl_Image\n"
		"Fl_Tree_usericon(Fl_Tree self, Fl_Image val)\n"
		""},
	 { (char *)"Fl_Tree_openicon", _wrap_Fl_Tree_openicon, METH_VARARGS, (char *)"\n"
		"openicon() -> Fl_Image\n"
		"Fl_Tree_openicon(Fl_Tree self, Fl_Image val)\n"
		""},
	 { (char *)"Fl_Tree_closeicon", _wrap_Fl_Tree_closeicon, METH_VARARGS, (char *)"\n"
		"closeicon() -> Fl_Image\n"
		"Fl_Tree_closeicon(Fl_Tree self, Fl_Image val)\n"
		""},
	 { (char *)"Fl_Tree_showcollapse", _wrap_Fl_Tree_showcollapse, METH_VARARGS, (char *)"\n"
		"showcollapse() -> int\n"
		"Fl_Tree_showcollapse(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_showroot", _wrap_Fl_Tree_showroot, METH_VARARGS, (char *)"\n"
		"showroot() -> int\n"
		"Fl_Tree_showroot(Fl_Tree self, int val)\n"
		""},
	 { (char *)"Fl_Tree_connectorstyle", _wrap_Fl_Tree_connectorstyle, METH_VARARGS, (char *)"\n"
		"connectorstyle() -> Fl_Tree_Connector\n"
		"Fl_Tree_connectorstyle(Fl_Tree self, Fl_Tree_Connector val)\n"
		""},
	 { (char *)"Fl_Tree_sortorder", _wrap_Fl_Tree_sortorder, METH_VARARGS, (char *)"\n"
		"sortorder() -> Fl_Tree_Sort\n"
		"Fl_Tree_sortorder(Fl_Tree self, Fl_Tree_Sort val)\n"
		""},
	 { (char *)"Fl_Tree_selectbox", _wrap_Fl_Tree_selectbox, METH_VARARGS, (char *)"\n"
		"selectbox() -> Fl_Boxtype\n"
		"Fl_Tree_selectbox(Fl_Tree self, Fl_Boxtype val)\n"
		""},
	 { (char *)"Fl_Tree_selectmode", _wrap_Fl_Tree_selectmode, METH_VARARGS, (char *)"\n"
		"selectmode() -> Fl_Tree_Select\n"
		"Fl_Tree_selectmode(Fl_Tree self, Fl_Tree_Select val)\n"
		""},
	 { (char *)"Fl_Tree_recalc_tree", _wrap_Fl_Tree_recalc_tree, METH_VARARGS, (char *)"Fl_Tree_recalc_tree(Fl_Tree self)"},
	 { (char *)"Fl_Tree_displayed", _wrap_Fl_Tree_displayed, METH_VARARGS, (char *)"Fl_Tree_displayed(Fl_Tree self, Fl_Tree_Item item) -> int"},
	 { (char *)"Fl_Tree_show_item", _wrap_Fl_Tree_show_item, METH_VARARGS, (char *)"\n"
		"show_item(Fl_Tree_Item item, int yoff)\n"
		"Fl_Tree_show_item(Fl_Tree self, Fl_Tree_Item item)\n"
		""},
	 { (char *)"Fl_Tree_show_item_top", _wrap_Fl_Tree_show_item_top, METH_VARARGS, (char *)"Fl_Tree_show_item_top(Fl_Tree self, Fl_Tree_Item item)"},
	 { (char *)"Fl_Tree_show_item_middle", _wrap_Fl_Tree_show_item_middle, METH_VARARGS, (char *)"Fl_Tree_show_item_middle(Fl_Tree self, Fl_Tree_Item item)"},
	 { (char *)"Fl_Tree_show_item_bottom", _wrap_Fl_Tree_show_item_bottom, METH_VARARGS, (char *)"Fl_Tree_show_item_bottom(Fl_Tree self, Fl_Tree_Item item)"},
	 { (char *)"Fl_Tree_display", _wrap_Fl_Tree_display, METH_VARARGS, (char *)"Fl_Tree_display(Fl_Tree self, Fl_Tree_Item item)"},
	 { (char *)"Fl_Tree_vposition", _wrap_Fl_Tree_vposition, METH_VARARGS, (char *)"\n"
		"vposition() -> int\n"
		"Fl_Tree_vposition(Fl_Tree self, int pos)\n"
		""},
	 { (char *)"Fl_Tree_hposition", _wrap_Fl_Tree_hposition, METH_VARARGS, (char *)"\n"
		"hposition() -> int\n"
		"Fl_Tree_hposition(Fl_Tree self, int pos)\n"
		""},
	 { (char *)"Fl_Tree_is_scrollbar", _wrap_Fl_Tree_is_scrollbar, METH_VARARGS, (char *)"Fl_Tree_is_scrollbar(Fl_Tree self, Fl_Widget w) -> int"},
	 { (char *)"Fl_Tree_scrollbar_size", _wrap_Fl_Tree_scrollbar_size, METH_VARARGS, (char *)"\n"
		"scrollbar_size() -> int\n"
		"Fl_Tree_scrollbar_size(Fl_Tree self, int size)\n"
		""},
	 { (char *)"Fl_Tree_is_vscroll_visible", _wrap_Fl_Tree_is_vscroll_visible, METH_VARARGS, (char *)"Fl_Tree_is_vscroll_visible(Fl_Tree self) -> int"},
	 { (char *)"Fl_Tree_is_hscroll_visible", _wrap_Fl_Tree_is_hscroll_visible, METH_VARARGS, (char *)"Fl_Tree_is_hscroll_visible(Fl_Tree self) -> int"},
	 { (char *)"Fl_Tree_callback_item", _wrap_Fl_Tree_callback_item, METH_VARARGS, (char *)"\n"
		"callback_item(Fl_Tree_Item item)\n"
		"Fl_Tree_callback_item(Fl_Tree self) -> Fl_Tree_Item\n"
		""},
	 { (char *)"Fl_Tree_callback_reason", _wrap_Fl_Tree_callback_reason, METH_VARARGS, (char *)"\n"
		"callback_reason(Fl_Tree_Reason reason)\n"
		"Fl_Tree_callback_reason(Fl_Tree self) -> Fl_Tree_Reason\n"
		""},
	 { (char *)"Fl_Tree_load", _wrap_Fl_Tree_load, METH_VARARGS, (char *)"Fl_Tree_load(Fl_Tree self, Fl_Preferences arg2)"},
	 { (char *)"disown_Fl_Tree", _wrap_disown_Fl_Tree, METH_VARARGS, NULL},
	 { (char *)"Fl_Tree_swigregister", Fl_Tree_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Fl_Paged_Device", _wrap_new_Fl_Paged_Device, METH_VARARGS, (char *)"new_Fl_Paged_Device(PyObject * self) -> Fl_Paged_Device"},
	 { (char *)"Fl_Paged_Device_class_name", _wrap_Fl_Paged_Device_class_name, METH_VARARGS, (char *)"Fl_Paged_Device_class_name(Fl_Paged_Device self) -> char const *"},
	 { (char *)"Fl_Paged_Device_start_job", _wrap_Fl_Paged_Device_start_job, METH_VARARGS, (char *)"Fl_Paged_Device_start_job(Fl_Paged_Device self, int pagecount, int * frompage=None, int * topage=None) -> int"},
	 { (char *)"Fl_Paged_Device_start_page", _wrap_Fl_Paged_Device_start_page, METH_VARARGS, (char *)"Fl_Paged_Device_start_page(Fl_Paged_Device self) -> int"},
	 { (char *)"Fl_Paged_Device_printable_rect", _wrap_Fl_Paged_Device_printable_rect, METH_VARARGS, (char *)"Fl_Paged_Device_printable_rect(Fl_Paged_Device self, int * w, int * h) -> int"},
	 { (char *)"Fl_Paged_Device_margins", _wrap_Fl_Paged_Device_margins, METH_VARARGS, (char *)"Fl_Paged_Device_margins(Fl_Paged_Device self, int * left, int * top, int * right, int * bottom)"},
	 { (char *)"Fl_Paged_Device_origin", _wrap_Fl_Paged_Device_origin, METH_VARARGS, (char *)"\n"
		"origin(int x, int y)\n"
		"Fl_Paged_Device_origin(Fl_Paged_Device self, int * x, int * y)\n"
		""},
	 { (char *)"Fl_Paged_Device_scale", _wrap_Fl_Paged_Device_scale, METH_VARARGS, (char *)"Fl_Paged_Device_scale(Fl_Paged_Device self, float scale_x, float scale_y=0.)"},
	 { (char *)"Fl_Paged_Device_rotate", _wrap_Fl_Paged_Device_rotate, METH_VARARGS, (char *)"Fl_Paged_Device_rotate(Fl_Paged_Device self, float angle)"},
	 { (char *)"Fl_Paged_Device_translate", _wrap_Fl_Paged_Device_translate, METH_VARARGS, (char *)"Fl_Paged_Device_translate(Fl_Paged_Device self, int x, int y)"},
	 { (char *)"Fl_Paged_Device_untranslate", _wrap_Fl_Paged_Device_untranslate, METH_VARARGS, (char *)"Fl_Paged_Device_untranslate(Fl_Paged_Device self)"},
	 { (char *)"Fl_Paged_Device_print_widget", _wrap_Fl_Paged_Device_print_widget, METH_VARARGS, (char *)"Fl_Paged_Device_print_widget(Fl_Paged_Device self, Fl_Widget widget, int delta_x=0, int delta_y=0)"},
	 { (char *)"Fl_Paged_Device_print_window", _wrap_Fl_Paged_Device_print_window, METH_VARARGS, (char *)"Fl_Paged_Device_print_window(Fl_Paged_Device self, Fl_Window win, int x_offset=0, int y_offset=0)"},
	 { (char *)"Fl_Paged_Device_print_window_part", _wrap_Fl_Paged_Device_print_window_part, METH_VARARGS, (char *)"Fl_Paged_Device_print_window_part(Fl_Paged_Device self, Fl_Window win, int x, int y, int w, int h, int delta_x=0, int delta_y=0)"},
	 { (char *)"Fl_Paged_Device_end_page", _wrap_Fl_Paged_Device_end_page, METH_VARARGS, (char *)"Fl_Paged_Device_end_page(Fl_Paged_Device self) -> int"},
	 { (char *)"Fl_Paged_Device_end_job", _wrap_Fl_Paged_Device_end_job, METH_VARARGS, (char *)"Fl_Paged_Device_end_job(Fl_Paged_Device self)"},
	 { (char *)"disown_Fl_Paged_Device", _wrap_disown_Fl_Paged_Device, METH_VARARGS, NULL},
	 { (char *)"Fl_Paged_Device_swigregister", Fl_Paged_Device_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Printer_class_name", _wrap_Fl_Printer_class_name, METH_VARARGS, (char *)"Fl_Printer_class_name(Fl_Printer self) -> char const *"},
	 { (char *)"new_Fl_Printer", _wrap_new_Fl_Printer, METH_VARARGS, (char *)"new_Fl_Printer(PyObject * self) -> Fl_Printer"},
	 { (char *)"Fl_Printer_start_job", _wrap_Fl_Printer_start_job, METH_VARARGS, (char *)"Fl_Printer_start_job(Fl_Printer self, int pagecount, int * frompage=None, int * topage=None) -> int"},
	 { (char *)"Fl_Printer_start_page", _wrap_Fl_Printer_start_page, METH_VARARGS, (char *)"Fl_Printer_start_page(Fl_Printer self) -> int"},
	 { (char *)"Fl_Printer_printable_rect", _wrap_Fl_Printer_printable_rect, METH_VARARGS, (char *)"Fl_Printer_printable_rect(Fl_Printer self, int * w, int * h) -> int"},
	 { (char *)"Fl_Printer_margins", _wrap_Fl_Printer_margins, METH_VARARGS, (char *)"Fl_Printer_margins(Fl_Printer self, int * left, int * top, int * right, int * bottom)"},
	 { (char *)"Fl_Printer_origin", _wrap_Fl_Printer_origin, METH_VARARGS, (char *)"\n"
		"origin(int * x, int * y)\n"
		"Fl_Printer_origin(Fl_Printer self, int x, int y)\n"
		""},
	 { (char *)"Fl_Printer_scale", _wrap_Fl_Printer_scale, METH_VARARGS, (char *)"Fl_Printer_scale(Fl_Printer self, float scale_x, float scale_y=0.)"},
	 { (char *)"Fl_Printer_rotate", _wrap_Fl_Printer_rotate, METH_VARARGS, (char *)"Fl_Printer_rotate(Fl_Printer self, float angle)"},
	 { (char *)"Fl_Printer_translate", _wrap_Fl_Printer_translate, METH_VARARGS, (char *)"Fl_Printer_translate(Fl_Printer self, int x, int y)"},
	 { (char *)"Fl_Printer_untranslate", _wrap_Fl_Printer_untranslate, METH_VARARGS, (char *)"Fl_Printer_untranslate(Fl_Printer self)"},
	 { (char *)"Fl_Printer_end_page", _wrap_Fl_Printer_end_page, METH_VARARGS, (char *)"Fl_Printer_end_page(Fl_Printer self) -> int"},
	 { (char *)"Fl_Printer_end_job", _wrap_Fl_Printer_end_job, METH_VARARGS, (char *)"Fl_Printer_end_job(Fl_Printer self)"},
	 { (char *)"Fl_Printer_print_widget", _wrap_Fl_Printer_print_widget, METH_VARARGS, (char *)"Fl_Printer_print_widget(Fl_Printer self, Fl_Widget widget, int delta_x=0, int delta_y=0)"},
	 { (char *)"Fl_Printer_print_window_part", _wrap_Fl_Printer_print_window_part, METH_VARARGS, (char *)"Fl_Printer_print_window_part(Fl_Printer self, Fl_Window win, int x, int y, int w, int h, int delta_x=0, int delta_y=0)"},
	 { (char *)"Fl_Printer_set_current", _wrap_Fl_Printer_set_current, METH_VARARGS, (char *)"Fl_Printer_set_current(Fl_Printer self)"},
	 { (char *)"Fl_Printer_driver", _wrap_Fl_Printer_driver, METH_VARARGS, (char *)"Fl_Printer_driver(Fl_Printer self) -> Fl_Graphics_Driver *"},
	 { (char *)"delete_Fl_Printer", _wrap_delete_Fl_Printer, METH_VARARGS, (char *)"delete_Fl_Printer(Fl_Printer self)"},
	 { (char *)"disown_Fl_Printer", _wrap_disown_Fl_Printer, METH_VARARGS, NULL},
	 { (char *)"Fl_Printer_swigregister", Fl_Printer_swigregister, METH_VARARGS, NULL},
	 { (char *)"fl_utf8bytes", _wrap_fl_utf8bytes, METH_VARARGS, (char *)"fl_utf8bytes(unsigned int ucs) -> int"},
	 { (char *)"fl_utf8len", _wrap_fl_utf8len, METH_VARARGS, (char *)"fl_utf8len(char c) -> int"},
	 { (char *)"fl_utf_nb_char", _wrap_fl_utf_nb_char, METH_VARARGS, (char *)"fl_utf_nb_char(unsigned char const * buf, int len) -> int"},
	 { (char *)"fl_utf8decode", _wrap_fl_utf8decode, METH_VARARGS, (char *)"fl_utf8decode(char const * p, char const * end, int * len) -> unsigned int"},
	 { (char *)"fl_utf8encode", _wrap_fl_utf8encode, METH_VARARGS, (char *)"fl_utf8encode(unsigned int ucs) -> int"},
	 { (char *)"fl_utf8fwd", _wrap_fl_utf8fwd, METH_VARARGS, (char *)"fl_utf8fwd(char const * p, char const * start, char const * end) -> char const *"},
	 { (char *)"fl_utf8back", _wrap_fl_utf8back, METH_VARARGS, (char *)"fl_utf8back(char const * p, char const * start, char const * end) -> char const *"},
	 { (char *)"fl_utf8toUtf16", _wrap_fl_utf8toUtf16, METH_VARARGS, (char *)"fl_utf8toUtf16(char const * src, unsigned int srclen, unsigned int dstlen) -> unsigned int"},
	 { (char *)"fl_utf8toa", _wrap_fl_utf8toa, METH_VARARGS, (char *)"fl_utf8toa(char const * src, unsigned int srclen, unsigned int OUTPUT) -> unsigned int"},
	 { (char *)"fl_utf8froma", _wrap_fl_utf8froma, METH_VARARGS, (char *)"fl_utf8froma(char * dst, unsigned int dstlen, char const * src, unsigned int srclen) -> unsigned int"},
	 { (char *)"fl_utf8locale", _wrap_fl_utf8locale, METH_VARARGS, (char *)"fl_utf8locale() -> int"},
	 { (char *)"fl_utf8test", _wrap_fl_utf8test, METH_VARARGS, (char *)"fl_utf8test(char const * src, unsigned int len) -> int"},
	 { (char *)"fl_nonspacing", _wrap_fl_nonspacing, METH_VARARGS, (char *)"fl_nonspacing(unsigned int ucs) -> unsigned int"},
	 { (char *)"fl_utf8to_mb", _wrap_fl_utf8to_mb, METH_VARARGS, (char *)"fl_utf8to_mb(char const * src, unsigned int srclen, char * dst, unsigned int dstlen) -> unsigned int"},
	 { (char *)"fl_utf2mbcs", _wrap_fl_utf2mbcs, METH_VARARGS, (char *)"fl_utf2mbcs(char const * src) -> char *"},
	 { (char *)"fl_utf8from_mb", _wrap_fl_utf8from_mb, METH_VARARGS, (char *)"fl_utf8from_mb(char * dst, unsigned int dstlen, char const * src, unsigned int srclen) -> unsigned int"},
	 { (char *)"fl_utf_strncasecmp", _wrap_fl_utf_strncasecmp, METH_VARARGS, (char *)"fl_utf_strncasecmp(char const * s1, char const * s2, int n) -> int"},
	 { (char *)"fl_utf_strcasecmp", _wrap_fl_utf_strcasecmp, METH_VARARGS, (char *)"fl_utf_strcasecmp(char const * s1, char const * s2) -> int"},
	 { (char *)"fl_tolower", _wrap_fl_tolower, METH_VARARGS, (char *)"fl_tolower(unsigned int ucs) -> int"},
	 { (char *)"fl_toupper", _wrap_fl_toupper, METH_VARARGS, (char *)"fl_toupper(unsigned int ucs) -> int"},
	 { (char *)"fl_utf_tolower", _wrap_fl_utf_tolower, METH_VARARGS, (char *)"fl_utf_tolower(unsigned char const * str, int len) -> int"},
	 { (char *)"fl_utf_toupper", _wrap_fl_utf_toupper, METH_VARARGS, (char *)"fl_utf_toupper(unsigned char const * str, int len, char * buf) -> int"},
	 { (char *)"fl_chmod", _wrap_fl_chmod, METH_VARARGS, (char *)"fl_chmod(char const * f, int mode) -> int"},
	 { (char *)"fl_access", _wrap_fl_access, METH_VARARGS, (char *)"fl_access(char const * f, int mode) -> int"},
	 { (char *)"fl_getcwd", _wrap_fl_getcwd, METH_VARARGS, (char *)"fl_getcwd(char * buf, int maxlen) -> char *"},
	 { (char *)"fl_fopen", _wrap_fl_fopen, METH_VARARGS, (char *)"fl_fopen(char const * f, char const * mode) -> FILE *"},
	 { (char *)"fl_system", _wrap_fl_system, METH_VARARGS, (char *)"fl_system(char const * f) -> int"},
	 { (char *)"fl_execvp", _wrap_fl_execvp, METH_VARARGS, (char *)"fl_execvp(char const * file, char *const * argv) -> int"},
	 { (char *)"fl_open", _wrap_fl_open, METH_VARARGS, (char *)"fl_open(char const * f, int o) -> int"},
	 { (char *)"fl_unlink", _wrap_fl_unlink, METH_VARARGS, (char *)"fl_unlink(char const * f) -> int"},
	 { (char *)"fl_rmdir", _wrap_fl_rmdir, METH_VARARGS, (char *)"fl_rmdir(char const * f) -> int"},
	 { (char *)"fl_getenv", _wrap_fl_getenv, METH_VARARGS, (char *)"fl_getenv(char const * name) -> char *"},
	 { (char *)"fl_mkdir", _wrap_fl_mkdir, METH_VARARGS, (char *)"fl_mkdir(char const * f, int mode) -> int"},
	 { (char *)"fl_rename", _wrap_fl_rename, METH_VARARGS, (char *)"fl_rename(char const * f, char const * t) -> int"},
	 { (char *)"fl_make_path_for_file", _wrap_fl_make_path_for_file, METH_VARARGS, (char *)"fl_make_path_for_file(char const * path)"},
	 { (char *)"fl_make_path", _wrap_fl_make_path, METH_VARARGS, (char *)"fl_make_path(char const * path) -> char"},
	 { (char *)"upCB", _wrap_upCB, METH_VARARGS, (char *)"upCB(Fl_Widget v, void * arg2)"},
	 { (char *)"downCB", _wrap_downCB, METH_VARARGS, (char *)"downCB(Fl_Widget v, void * arg2)"},
	 { (char *)"toggleCB", _wrap_toggleCB, METH_VARARGS, (char *)"toggleCB(Fl_Widget v, void * arg2)"},
	 { (char *)"new_ListSelect", _wrap_new_ListSelect, METH_VARARGS, (char *)"new_ListSelect(PyObject * self, int x, int y, int w, int h, char * topLabel=None, char * bottomLabel=None) -> ListSelect"},
	 { (char *)"ListSelect_getTopBrowser", _wrap_ListSelect_getTopBrowser, METH_VARARGS, (char *)"ListSelect_getTopBrowser(ListSelect self) -> Fl_Multi_Browser"},
	 { (char *)"ListSelect_getBottomBrowser", _wrap_ListSelect_getBottomBrowser, METH_VARARGS, (char *)"ListSelect_getBottomBrowser(ListSelect self) -> Fl_Multi_Browser"},
	 { (char *)"ListSelect_resize", _wrap_ListSelect_resize, METH_VARARGS, (char *)"ListSelect_resize(ListSelect self, int x, int y, int w, int h)"},
	 { (char *)"delete_ListSelect", _wrap_delete_ListSelect, METH_VARARGS, (char *)"delete_ListSelect(ListSelect self)"},
	 { (char *)"disown_ListSelect", _wrap_disown_ListSelect, METH_VARARGS, NULL},
	 { (char *)"ListSelect_draw", _wrap_ListSelect_draw, METH_VARARGS, (char *)"ListSelect_draw(ListSelect self)"},
	 { (char *)"ListSelect_swigregister", ListSelect_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Table_handle", _wrap_Fl_Table_handle, METH_VARARGS, (char *)"Fl_Table_handle(Fl_Table self, int e) -> int"},
	 { (char *)"Fl_Table_draw_cell", _wrap_Fl_Table_draw_cell, METH_VARARGS, (char *)"\n"
		"Fl_Table_draw_cell(Fl_Table self, Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, \n"
		"    int W=0, int H=0)\n"
		""},
	 { (char *)"new_Fl_Table", _wrap_new_Fl_Table, METH_VARARGS, (char *)"new_Fl_Table(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Table"},
	 { (char *)"delete_Fl_Table", _wrap_delete_Fl_Table, METH_VARARGS, (char *)"delete_Fl_Table(Fl_Table self)"},
	 { (char *)"Fl_Table_clear", _wrap_Fl_Table_clear, METH_VARARGS, (char *)"Fl_Table_clear(Fl_Table self)"},
	 { (char *)"Fl_Table_table_box", _wrap_Fl_Table_table_box, METH_VARARGS, (char *)"\n"
		"table_box(Fl_Boxtype val)\n"
		"Fl_Table_table_box(Fl_Table self) -> Fl_Boxtype\n"
		""},
	 { (char *)"Fl_Table_rows", _wrap_Fl_Table_rows, METH_VARARGS, (char *)"\n"
		"rows(int val)\n"
		"Fl_Table_rows(Fl_Table self) -> int\n"
		""},
	 { (char *)"Fl_Table_cols", _wrap_Fl_Table_cols, METH_VARARGS, (char *)"\n"
		"cols(int val)\n"
		"Fl_Table_cols(Fl_Table self) -> int\n"
		""},
	 { (char *)"Fl_Table_visible_cells", _wrap_Fl_Table_visible_cells, METH_VARARGS, (char *)"Fl_Table_visible_cells(Fl_Table self)"},
	 { (char *)"Fl_Table_is_interactive_resize", _wrap_Fl_Table_is_interactive_resize, METH_VARARGS, (char *)"Fl_Table_is_interactive_resize(Fl_Table self) -> int"},
	 { (char *)"Fl_Table_row_resize", _wrap_Fl_Table_row_resize, METH_VARARGS, (char *)"\n"
		"row_resize() -> int\n"
		"Fl_Table_row_resize(Fl_Table self, int flag)\n"
		""},
	 { (char *)"Fl_Table_col_resize", _wrap_Fl_Table_col_resize, METH_VARARGS, (char *)"\n"
		"col_resize() -> int\n"
		"Fl_Table_col_resize(Fl_Table self, int flag)\n"
		""},
	 { (char *)"Fl_Table_col_resize_min", _wrap_Fl_Table_col_resize_min, METH_VARARGS, (char *)"\n"
		"col_resize_min() -> int\n"
		"Fl_Table_col_resize_min(Fl_Table self, int val)\n"
		""},
	 { (char *)"Fl_Table_row_resize_min", _wrap_Fl_Table_row_resize_min, METH_VARARGS, (char *)"\n"
		"row_resize_min() -> int\n"
		"Fl_Table_row_resize_min(Fl_Table self, int val)\n"
		""},
	 { (char *)"Fl_Table_row_header", _wrap_Fl_Table_row_header, METH_VARARGS, (char *)"\n"
		"row_header() -> int\n"
		"Fl_Table_row_header(Fl_Table self, int flag)\n"
		""},
	 { (char *)"Fl_Table_col_header", _wrap_Fl_Table_col_header, METH_VARARGS, (char *)"\n"
		"col_header() -> int\n"
		"Fl_Table_col_header(Fl_Table self, int flag)\n"
		""},
	 { (char *)"Fl_Table_col_header_height", _wrap_Fl_Table_col_header_height, METH_VARARGS, (char *)"\n"
		"col_header_height(int height)\n"
		"Fl_Table_col_header_height(Fl_Table self) -> int\n"
		""},
	 { (char *)"Fl_Table_row_header_width", _wrap_Fl_Table_row_header_width, METH_VARARGS, (char *)"\n"
		"row_header_width(int width)\n"
		"Fl_Table_row_header_width(Fl_Table self) -> int\n"
		""},
	 { (char *)"Fl_Table_row_header_color", _wrap_Fl_Table_row_header_color, METH_VARARGS, (char *)"\n"
		"row_header_color(Fl_Color val)\n"
		"Fl_Table_row_header_color(Fl_Table self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Table_col_header_color", _wrap_Fl_Table_col_header_color, METH_VARARGS, (char *)"\n"
		"col_header_color(Fl_Color val)\n"
		"Fl_Table_col_header_color(Fl_Table self) -> Fl_Color\n"
		""},
	 { (char *)"Fl_Table_row_height", _wrap_Fl_Table_row_height, METH_VARARGS, (char *)"\n"
		"row_height(int row, int height)\n"
		"Fl_Table_row_height(Fl_Table self, int row) -> int\n"
		""},
	 { (char *)"Fl_Table_col_width", _wrap_Fl_Table_col_width, METH_VARARGS, (char *)"\n"
		"col_width(int col, int width)\n"
		"Fl_Table_col_width(Fl_Table self, int col) -> int\n"
		""},
	 { (char *)"Fl_Table_row_height_all", _wrap_Fl_Table_row_height_all, METH_VARARGS, (char *)"Fl_Table_row_height_all(Fl_Table self, int height)"},
	 { (char *)"Fl_Table_col_width_all", _wrap_Fl_Table_col_width_all, METH_VARARGS, (char *)"Fl_Table_col_width_all(Fl_Table self, int width)"},
	 { (char *)"Fl_Table_row_position", _wrap_Fl_Table_row_position, METH_VARARGS, (char *)"\n"
		"row_position(int row)\n"
		"Fl_Table_row_position(Fl_Table self) -> int\n"
		""},
	 { (char *)"Fl_Table_col_position", _wrap_Fl_Table_col_position, METH_VARARGS, (char *)"\n"
		"col_position(int col)\n"
		"Fl_Table_col_position(Fl_Table self) -> int\n"
		""},
	 { (char *)"Fl_Table_top_row", _wrap_Fl_Table_top_row, METH_VARARGS, (char *)"\n"
		"top_row(int row)\n"
		"Fl_Table_top_row(Fl_Table self) -> int\n"
		""},
	 { (char *)"Fl_Table_is_selected", _wrap_Fl_Table_is_selected, METH_VARARGS, (char *)"Fl_Table_is_selected(Fl_Table self, int r, int c) -> int"},
	 { (char *)"Fl_Table_get_selection", _wrap_Fl_Table_get_selection, METH_VARARGS, (char *)"Fl_Table_get_selection(Fl_Table self)"},
	 { (char *)"Fl_Table_set_selection", _wrap_Fl_Table_set_selection, METH_VARARGS, (char *)"Fl_Table_set_selection(Fl_Table self, int row_top, int col_left, int row_bot, int col_right)"},
	 { (char *)"Fl_Table_move_cursor", _wrap_Fl_Table_move_cursor, METH_VARARGS, (char *)"\n"
		"move_cursor(int R, int C, int shiftselect) -> int\n"
		"Fl_Table_move_cursor(Fl_Table self, int R, int C) -> int\n"
		""},
	 { (char *)"Fl_Table_resize", _wrap_Fl_Table_resize, METH_VARARGS, (char *)"Fl_Table_resize(Fl_Table self, int X, int Y, int W, int H)"},
	 { (char *)"Fl_Table_draw", _wrap_Fl_Table_draw, METH_VARARGS, (char *)"Fl_Table_draw(Fl_Table self)"},
	 { (char *)"Fl_Table_init_sizes", _wrap_Fl_Table_init_sizes, METH_VARARGS, (char *)"Fl_Table_init_sizes(Fl_Table self)"},
	 { (char *)"Fl_Table_add", _wrap_Fl_Table_add, METH_VARARGS, (char *)"Fl_Table_add(Fl_Table self, Fl_Widget wgt)"},
	 { (char *)"Fl_Table_insert", _wrap_Fl_Table_insert, METH_VARARGS, (char *)"Fl_Table_insert(Fl_Table self, Fl_Widget wgt, int n)"},
	 { (char *)"Fl_Table_insert_before", _wrap_Fl_Table_insert_before, METH_VARARGS, (char *)"Fl_Table_insert_before(Fl_Table self, Fl_Widget wgt, Fl_Widget w2)"},
	 { (char *)"Fl_Table_begin", _wrap_Fl_Table_begin, METH_VARARGS, (char *)"Fl_Table_begin(Fl_Table self)"},
	 { (char *)"Fl_Table_end", _wrap_Fl_Table_end, METH_VARARGS, (char *)"Fl_Table_end(Fl_Table self)"},
	 { (char *)"Fl_Table_child", _wrap_Fl_Table_child, METH_VARARGS, (char *)"Fl_Table_child(Fl_Table self, int n) -> Fl_Widget"},
	 { (char *)"Fl_Table_children", _wrap_Fl_Table_children, METH_VARARGS, (char *)"Fl_Table_children(Fl_Table self) -> int"},
	 { (char *)"Fl_Table_find", _wrap_Fl_Table_find, METH_VARARGS, (char *)"Fl_Table_find(Fl_Table self, Fl_Widget wgt) -> int"},
	 { (char *)"Fl_Table_callback_row", _wrap_Fl_Table_callback_row, METH_VARARGS, (char *)"Fl_Table_callback_row(Fl_Table self) -> int"},
	 { (char *)"Fl_Table_callback_col", _wrap_Fl_Table_callback_col, METH_VARARGS, (char *)"Fl_Table_callback_col(Fl_Table self) -> int"},
	 { (char *)"Fl_Table_callback_context", _wrap_Fl_Table_callback_context, METH_VARARGS, (char *)"Fl_Table_callback_context(Fl_Table self) -> Fl_Table::TableContext"},
	 { (char *)"Fl_Table_do_callback", _wrap_Fl_Table_do_callback, METH_VARARGS, (char *)"Fl_Table_do_callback(Fl_Table self, Fl_Table::TableContext context, int row, int col)"},
	 { (char *)"disown_Fl_Table", _wrap_disown_Fl_Table, METH_VARARGS, NULL},
	 { (char *)"Fl_Table_swigregister", Fl_Table_swigregister, METH_VARARGS, NULL},
	 { (char *)"Fl_Table_Row_handle", _wrap_Fl_Table_Row_handle, METH_VARARGS, (char *)"Fl_Table_Row_handle(Fl_Table_Row self, int event) -> int"},
	 { (char *)"new_Fl_Table_Row", _wrap_new_Fl_Table_Row, METH_VARARGS, (char *)"new_Fl_Table_Row(PyObject * self, int X, int Y, int W, int H, char const * l=None) -> Fl_Table_Row"},
	 { (char *)"delete_Fl_Table_Row", _wrap_delete_Fl_Table_Row, METH_VARARGS, (char *)"delete_Fl_Table_Row(Fl_Table_Row self)"},
	 { (char *)"Fl_Table_Row_rows", _wrap_Fl_Table_Row_rows, METH_VARARGS, (char *)"\n"
		"rows(int val)\n"
		"Fl_Table_Row_rows(Fl_Table_Row self) -> int\n"
		""},
	 { (char *)"Fl_Table_Row_type", _wrap_Fl_Table_Row_type, METH_VARARGS, (char *)"\n"
		"type(Fl_Table_Row::TableRowSelectMode val)\n"
		"Fl_Table_Row_type(Fl_Table_Row self) -> Fl_Table_Row::TableRowSelectMode\n"
		""},
	 { (char *)"Fl_Table_Row_row_selected", _wrap_Fl_Table_Row_row_selected, METH_VARARGS, (char *)"Fl_Table_Row_row_selected(Fl_Table_Row self, int row) -> int"},
	 { (char *)"Fl_Table_Row_select_row", _wrap_Fl_Table_Row_select_row, METH_VARARGS, (char *)"Fl_Table_Row_select_row(Fl_Table_Row self, int row, int flag=1) -> int"},
	 { (char *)"Fl_Table_Row_select_all_rows", _wrap_Fl_Table_Row_select_all_rows, METH_VARARGS, (char *)"Fl_Table_Row_select_all_rows(Fl_Table_Row self, int flag=1)"},
	 { (char *)"Fl_Table_Row_clear", _wrap_Fl_Table_Row_clear, METH_VARARGS, (char *)"Fl_Table_Row_clear(Fl_Table_Row self)"},
	 { (char *)"disown_Fl_Table_Row", _wrap_disown_Fl_Table_Row, METH_VARARGS, NULL},
	 { (char *)"Fl_Table_Row_draw_cell", _wrap_Fl_Table_Row_draw_cell, METH_VARARGS, (char *)"\n"
		"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, \n"
		"    int W=0, int H=0)\n"
		""},
	 { (char *)"Fl_Table_Row_swigregister", Fl_Table_Row_swigregister, METH_VARARGS, NULL},
	 { (char *)"glLoadIdentity", _wrap_glLoadIdentity, METH_VARARGS, (char *)"glLoadIdentity()"},
	 { (char *)"glViewport", _wrap_glViewport, METH_VARARGS, (char *)"glViewport(int x, int y, int width, int height)"},
	 { (char *)"glClear", _wrap_glClear, METH_VARARGS, (char *)"glClear(int mask)"},
	 { (char *)"glColor3f", _wrap_glColor3f, METH_VARARGS, (char *)"glColor3f(float red, float green, float blue)"},
	 { (char *)"glBegin", _wrap_glBegin, METH_VARARGS, (char *)"glBegin(int mode)"},
	 { (char *)"glEnd", _wrap_glEnd, METH_VARARGS, (char *)"glEnd()"},
	 { (char *)"glVertex3f", _wrap_glVertex3f, METH_VARARGS, (char *)"glVertex3f(float x, float y, float z)"},
	 { (char *)"setMenu", setMenu, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


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

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_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_Menu_BarTo_p_Fl_Menu_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_ *)  ((Fl_Menu_Bar *) 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_ButtonTo_p_Fl_Menu_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Menu_ *)  ((Fl_Menu_Button *) 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_Multiline_OutputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *) (Fl_Output *) ((Fl_Multiline_Output *) 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_Multiline_InputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_Multiline_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_Secret_InputTo_p_Fl_Input(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input *)  ((Fl_Secret_Input *) 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_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *)  ((Fl_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_Check_BrowserTo_p_Fl_Browser_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Browser_ *)  ((Fl_Check_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_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_Round_ClockTo_p_Fl_Clock(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Clock *)  ((Fl_Round_Clock *) 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_TreeTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Tree *) 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_FreeTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Free *) 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_PositionerTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Positioner *) 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_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_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_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_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_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_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_SliderTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Slider *) 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_Text_DisplayTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Text_Display *) 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_ValuatorTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Valuator *) x));
}
static void *_p_Fl_TimerTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Timer *) 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_DialTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Dial *) 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_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_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_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *) ((Fl_Input *) 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_Return_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Return_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_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_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_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_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Radio_Button *) 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_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_Light_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Light_Button *) 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_Toggle_ButtonTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Button *) ((Fl_Toggle_Button *) 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_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_CounterTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Counter *) 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_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_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_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_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_BrowserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *)(Fl_Browser_ *) ((Fl_Browser *) 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_OutputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Input_ *)(Fl_Input *) ((Fl_Output *) 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_Flcc_ValueBoxTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Flcc_ValueBox *) 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_Flcc_HueBoxTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Flcc_HueBox *) 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_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_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_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_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_WindowTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Window *) 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_Menu_To_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Menu_ *) x));
}
static void *_p_Fl_FormsBitmapTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_FormsBitmap *) 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_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_Value_InputTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Value_Input *) 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_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_TabsTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Tabs *) 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_AdjusterTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Valuator *) ((Fl_Adjuster *) 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_ClockTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Clock_Output *) ((Fl_Clock *) 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_FormsPixmapTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_FormsPixmap *) 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_BoxTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Box *) 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_ProgressTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *)  ((Fl_Progress *) 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_PackTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Pack *) 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_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_Color_ChooserTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Color_Chooser *) 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_Input_ChoiceTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Input_Choice *) 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_WizardTo_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget *) (Fl_Group *) ((Fl_Wizard *) 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_TableTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Table **) x));
}
static void *_p_p_Fl_FreeTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Free **) 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_PositionerTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Positioner **) 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_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_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_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_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_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_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_SliderTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Slider **) 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_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_TileTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Tile **) 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_TimerTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Timer **) 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_DialTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Dial **) 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_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_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_InputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Input_ *) ((Fl_Input **) 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_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_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_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_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_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_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_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_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_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_ButtonTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Button **) 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_ListSelectTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((ListSelect **) 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_CounterTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Counter **) 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_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_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_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_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_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_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_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_Clock_OutputTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Clock_Output **) 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_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_Flcc_HueBoxTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Flcc_HueBox **) 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_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_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_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_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_WindowTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Window **) 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_Menu_To_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Menu_ **) x));
}
static void *_p_p_Fl_FormsBitmapTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_FormsBitmap **) 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_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_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_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_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_TabsTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Tabs **) 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_AdjusterTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Adjuster **) 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_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_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_FormsPixmapTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_FormsPixmap **) 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_BoxTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Box **) 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_ProgressTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **)  ((Fl_Progress **) 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_PackTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Group *) ((Fl_Pack **) 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_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_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_RollerTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Valuator *) ((Fl_Roller **) 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_ChoiceTo_p_p_Fl_Widget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Widget **) (Fl_Menu_ *) ((Fl_Choice **) 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_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_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_Light_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Light_Button *) 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_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_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_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_Toggle_ButtonTo_p_Fl_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Button *)  ((Fl_Toggle_Button *) 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_Round_ButtonTo_p_Fl_Light_Button(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Light_Button *)  ((Fl_Round_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_OutputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_Output *) 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_File_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_File_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_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *)  ((Fl_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_Int_InputTo_p_Fl_Input_(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Input_ *) (Fl_Input *) ((Fl_Int_Input *) 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_Simple_CounterTo_p_Fl_Counter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Counter *)  ((Fl_Simple_Counter *) 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_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_Menu_WindowTo_p_Fl_Single_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Single_Window *)  ((Fl_Menu_Window *) 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_Single_WindowTo_p_Fl_Window(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Window *)  ((Fl_Single_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_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_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_Single_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Window *) ((Fl_Single_Window *) 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_Double_WindowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Window *) ((Fl_Double_Window *) 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_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_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_Color_ChooserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Color_Chooser *) 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_WizardTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Wizard *) 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_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_Check_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *) ((Fl_Check_Browser *) 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_BrowserTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Browser_ *) ((Fl_Browser *) 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_ScrollTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Scroll *) 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_TableTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Table *) 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_PackTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Pack *) x));
}
static void *_p_ListSelectTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((ListSelect *) 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_SpinnerTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *)  ((Fl_Spinner *) 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_Table_RowTo_p_Fl_Group(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Group *) (Fl_Table *) ((Fl_Table_Row *) 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_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_ScrollbarTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Scrollbar *) 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_Value_SliderTo_p_Fl_Slider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Slider *)  ((Fl_Value_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_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_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_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_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_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_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_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_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_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_BMP_ImageTo_p_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image **)  ((Fl_BMP_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_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_RGB_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *)  ((Fl_RGB_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_GIF_ImageTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *) (Fl_Pixmap *) ((Fl_GIF_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_PixmapTo_p_Fl_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Image *)  ((Fl_Pixmap *) 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_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_BMP_ImageTo_p_Fl_RGB_Image(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_RGB_Image *)  ((Fl_BMP_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_GIF_ImageTo_p_Fl_Pixmap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Pixmap *)  ((Fl_GIF_Image *) x));
}
static void *_p_Fl_AdjusterTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Adjuster *) 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_Fl_Value_InputTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Value_Input *) 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_DialTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Dial *) 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_Simple_CounterTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Counter *) ((Fl_Simple_Counter *) 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_Value_OutputTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Value_Output *) 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_Value_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Value_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_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_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_Fill_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Fill_Slider *) 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_Nice_SliderTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *) (Fl_Slider *) ((Fl_Nice_Slider *) 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_RollerTo_p_Fl_Valuator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fl_Valuator *)  ((Fl_Roller *) 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 = {"_p_Fl", "Fl *", 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_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_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_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_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_Counter = {"_p_Fl_Counter", "Fl_Counter *", 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_Double_Window = {"_p_Fl_Double_Window", "Fl_Double_Window *", 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_Float_Input = {"_p_Fl_Float_Input", "Fl_Float_Input *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_FormsBitmap = {"_p_Fl_FormsBitmap", "Fl_FormsBitmap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_FormsPixmap = {"_p_Fl_FormsPixmap", "Fl_FormsPixmap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Free = {"_p_Fl_Free", "Fl_Free *", 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_Group = {"_p_Fl_Group", "Fl_Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Help_Block = {"_p_Fl_Help_Block", "Fl_Help_Block *", 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_Font_Stack = {"_p_Fl_Help_Font_Stack", "Fl_Help_Font_Stack *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Help_Font_Style = {"_p_Fl_Help_Font_Style", "Fl_Help_Font_Style *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Help_Link = {"_p_Fl_Help_Link", "Fl_Help_Link *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Help_Target = {"_p_Fl_Help_Target", "Fl_Help_Target *", 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_Image = {"_p_Fl_Image", "Fl_Image *", 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_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_Nice_Slider = {"_p_Fl_Nice_Slider", "Fl_Nice_Slider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Option = {"_p_Fl_Option", "Fl_Option *", 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_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_Positioner = {"_p_Fl_Positioner", "Fl_Positioner *", 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_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_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_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_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_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_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_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_Timer = {"_p_Fl_Timer", "Fl_Timer *", 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_Widget = {"_p_Fl_Widget", "Fl_Widget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fl_Widget_Tracker = {"_p_Fl_Widget_Tracker", "Fl_Widget_Tracker *", 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_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_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_ListSelect = {"_p_ListSelect", "ListSelect *", 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_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___void = {"_p_f___void", "void (*)()|Fl_Old_Idle_Handler", 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", "void (*)(int,int,int,int,char const *,void *)|Fl_Text_Modify_Cb", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_int_int_int_unsigned_int__void = {"_p_f_int_int_int_int_unsigned_int__void", "void (*)(int,int,int,int,unsigned int)|Fl_Box_Draw_F *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_int_p_void__void = {"_p_f_int_int_p_void__void", "void (*)(int,int,void *)|Fl_Text_Predelete_Cb", 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", "int (*)(int,Fl_Text_Editor *)|Fl_Text_Editor::Key_Func", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_p_Fl_Window__int = {"_p_f_int_p_Fl_Window__int", "int (*)(int,Fl_Window *)|Fl_Event_Dispatch", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_p_p_char_r_int__int = {"_p_f_int_p_p_char_r_int__int", "Fl_Args_Handler|int (*)(int,char **,int &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_p_void__void = {"_p_f_int_p_void__void", "Fl_Clipboard_Notify_Handler|void (*)(int,void *)", 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_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_int_float_float_char__int = {"_p_f_p_Fl_Widget_int_float_float_char__int", "FL_HANDLEPTR|int (*)(Fl_Widget *,int,float,float,char)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_Widget_long__void = {"_p_f_p_Fl_Widget_long__void", "void (*)(Fl_Widget *,long)|Fl_Callback1 *", 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_p|Fl_Callback *|void (*)(Fl_Widget *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_Fl_Window_p_void__void = {"_p_f_p_Fl_Window_p_void__void", "Fl_Atclose_Handler|void (*)(Fl_Window *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void = {"_p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void", "Fl_Label_Draw_F *|void (*)(Fl_Label const *,int,int,int,int,unsigned int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__Fl_Label_r_int_r_int__void = {"_p_f_p_q_const__Fl_Label_r_int_r_int__void", "Fl_Label_Measure_F *|void (*)(Fl_Label const *,int &,int &)", 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_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_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_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_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_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_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_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_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_v_______void = {"_p_f_p_q_const__char_v_______void", "void (*)(char const *,...)|Fl_Abort_Handler", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "Fl_Awake_Handler|Fl_Timeout_Handler|Fl_Idle_Handler|void (*)(void *)", 0, 0, (void*)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_p_void_p_void__int = {"_p_f_p_void_p_void__int", "Fl_System_Handler|int (*)(void *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_int__void = {"_p_f_unsigned_int__void", "void (*)(unsigned int)|void (*)(Fl_Color)", 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", "int *|Fl_Fontsize *|Fl_Font *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "fl_intptr_t *|long *", 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_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_BMP_Image = {"_p_p_Fl_BMP_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_Tree = {"_p_p_Fl_Tree", 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_Free = {"_p_p_Fl_Free", 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_Positioner = {"_p_p_Fl_Positioner", 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_Tile = {"_p_p_Fl_Tile", 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_Value_Slider = {"_p_p_Fl_Value_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_Nice_Slider = {"_p_p_Fl_Hor_Nice_Slider", 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_Slider = {"_p_p_Fl_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_Nice_Slider = {"_p_p_Fl_Nice_Slider", 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_Valuator = {"_p_p_Fl_Valuator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Fl_Timer = {"_p_p_Fl_Timer", 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_Dial = {"_p_p_Fl_Dial", 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_ListSelect = {"_p_p_ListSelect", 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_Int_Input = {"_p_p_Fl_Int_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_Float_Input = {"_p_p_Fl_Float_Input", 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_Menu_Button = {"_p_p_Fl_Menu_Button", 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_Toggle_Button = {"_p_p_Fl_Toggle_Button", 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_Light_Button = {"_p_p_Fl_Light_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_Repeat_Button = {"_p_p_Fl_Repeat_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_Round_Button = {"_p_p_Fl_Round_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_Counter = {"_p_p_Fl_Counter", 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_Multi_Browser = {"_p_p_Fl_Multi_Browser", 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_Check_Browser = {"_p_p_Fl_Check_Browser", 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_Browser = {"_p_p_Fl_Browser", 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_Output = {"_p_p_Fl_Output", 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_Value_Output = {"_p_p_Fl_Value_Output", 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_Fl_Box = {"_p_p_Fl_Box", 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_Fl_Scrollbar = {"_p_p_Fl_Scrollbar", 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_Menu_Window = {"_p_p_Fl_Menu_Window", 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_Gl_Window = {"_p_p_Fl_Gl_Window", 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_Double_Window = {"_p_p_Fl_Double_Window", 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_FormsBitmap = {"_p_p_Fl_FormsBitmap", 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_Multiline_Input = {"_p_p_Fl_Multiline_Input", 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_Flcc_Value_Input = {"_p_p_Flcc_Value_Input", 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_Tabs = {"_p_p_Fl_Tabs", 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_Adjuster = {"_p_p_Fl_Adjuster", 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_Clock = {"_p_p_Fl_Clock", 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_FormsPixmap = {"_p_p_Fl_FormsPixmap", 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_Help_View = {"_p_p_Fl_Help_View", 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_Line_Dial = {"_p_p_Fl_Line_Dial", 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_Spinner = {"_p_p_Fl_Spinner", 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_Color_Chooser = {"_p_p_Fl_Color_Chooser", 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_Input_Choice = {"_p_p_Fl_Input_Choice", 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_Wizard = {"_p_p_Fl_Wizard", 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_dirent = {"_p_p_p_dirent", "dirent ***", 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_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_Char *|unsigned int *|Fl_Shortcut *|Fl_Color *|Fl_Align *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "fl_uintptr_t *|ulong *|unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_wchar_t = {"_p_wchar_t", "wchar_t *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_FILE,
  &_swigt__p_FL_CHART_ENTRY,
  &_swigt__p_Fl,
  &_swigt__p_Fl_Adjuster,
  &_swigt__p_Fl_BMP_Image,
  &_swigt__p_Fl_Bitmap,
  &_swigt__p_Fl_Box,
  &_swigt__p_Fl_Browser,
  &_swigt__p_Fl_Browser_,
  &_swigt__p_Fl_Button,
  &_swigt__p_Fl_Chart,
  &_swigt__p_Fl_Check_Browser,
  &_swigt__p_Fl_Check_Button,
  &_swigt__p_Fl_Choice,
  &_swigt__p_Fl_Clock,
  &_swigt__p_Fl_Clock_Output,
  &_swigt__p_Fl_Color_Chooser,
  &_swigt__p_Fl_Counter,
  &_swigt__p_Fl_Dial,
  &_swigt__p_Fl_Double_Window,
  &_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_Float_Input,
  &_swigt__p_Fl_FormsBitmap,
  &_swigt__p_Fl_FormsPixmap,
  &_swigt__p_Fl_Free,
  &_swigt__p_Fl_GIF_Image,
  &_swigt__p_Fl_Gl_Window,
  &_swigt__p_Fl_Graphics_Driver,
  &_swigt__p_Fl_Group,
  &_swigt__p_Fl_Help_Block,
  &_swigt__p_Fl_Help_Dialog,
  &_swigt__p_Fl_Help_Font_Stack,
  &_swigt__p_Fl_Help_Font_Style,
  &_swigt__p_Fl_Help_Link,
  &_swigt__p_Fl_Help_Target,
  &_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_Image,
  &_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_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_Nice_Slider,
  &_swigt__p_Fl_Option,
  &_swigt__p_Fl_Output,
  &_swigt__p_Fl_Overlay_Window,
  &_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_Positioner,
  &_swigt__p_Fl_Preferences,
  &_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_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_Scroll,
  &_swigt__p_Fl_Scrollbar,
  &_swigt__p_Fl_Secret_Input,
  &_swigt__p_Fl_Select_Browser,
  &_swigt__p_Fl_Shared_Image,
  &_swigt__p_Fl_Simple_Counter,
  &_swigt__p_Fl_Single_Window,
  &_swigt__p_Fl_Slider,
  &_swigt__p_Fl_Spinner,
  &_swigt__p_Fl_Table,
  &_swigt__p_Fl_Table_Row,
  &_swigt__p_Fl_Tabs,
  &_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_Selection,
  &_swigt__p_Fl_Tile,
  &_swigt__p_Fl_Tiled_Image,
  &_swigt__p_Fl_Timer,
  &_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_Widget,
  &_swigt__p_Fl_Widget_Tracker,
  &_swigt__p_Fl_Window,
  &_swigt__p_Fl_Wizard,
  &_swigt__p_Fl_XBM_Image,
  &_swigt__p_Fl_XPM_Image,
  &_swigt__p_Flcc_HueBox,
  &_swigt__p_Flcc_ValueBox,
  &_swigt__p_Flcc_Value_Input,
  &_swigt__p_ListSelect,
  &_swigt__p_Style_Table_Entry,
  &_swigt__p_char,
  &_swigt__p_double,
  &_swigt__p_f___void,
  &_swigt__p_f_int_int_int_int_p_q_const__char_p_void__void,
  &_swigt__p_f_int_int_int_int_unsigned_int__void,
  &_swigt__p_f_int_int_p_void__void,
  &_swigt__p_f_int_p_Fl_Text_Editor__int,
  &_swigt__p_f_int_p_Fl_Window__int,
  &_swigt__p_f_int_p_p_char_r_int__int,
  &_swigt__p_f_int_p_void__void,
  &_swigt__p_f_p_Fl_File_Chooser_p_void__void,
  &_swigt__p_f_p_Fl_Widget__void,
  &_swigt__p_f_p_Fl_Widget_int_float_float_char__int,
  &_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_Fl_Window_p_void__void,
  &_swigt__p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void,
  &_swigt__p_f_p_q_const__Fl_Label_r_int_r_int__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_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_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_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_q_const__char_v_______void,
  &_swigt__p_f_p_void__void,
  &_swigt__p_f_p_void_int_int_int_int__void,
  &_swigt__p_f_p_void_p_void__int,
  &_swigt__p_f_unsigned_int__void,
  &_swigt__p_float,
  &_swigt__p_int,
  &_swigt__p_long,
  &_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_Float_Input,
  &_swigt__p_p_Fl_FormsBitmap,
  &_swigt__p_p_Fl_FormsPixmap,
  &_swigt__p_p_Fl_Free,
  &_swigt__p_p_Fl_Gl_Window,
  &_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_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_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_Simple_Counter,
  &_swigt__p_p_Fl_Single_Window,
  &_swigt__p_p_Fl_Slider,
  &_swigt__p_p_Fl_Spinner,
  &_swigt__p_p_Fl_Table,
  &_swigt__p_p_Fl_Table_Row,
  &_swigt__p_p_Fl_Tabs,
  &_swigt__p_p_Fl_Text_Display,
  &_swigt__p_p_Fl_Text_Editor,
  &_swigt__p_p_Fl_Tile,
  &_swigt__p_p_Fl_Timer,
  &_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_dirent,
  &_swigt__p_short,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_void,
  &_swigt__p_wchar_t,
};

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[] = {  {&_swigt__p_Fl, 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_BMP_Image[] = {  {&_swigt__p_Fl_BMP_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Bitmap[] = {  {&_swigt__p_Fl_XBM_Image, _p_Fl_XBM_ImageTo_p_Fl_Bitmap, 0, 0},  {&_swigt__p_Fl_Bitmap, 0, 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_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_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},  {&_swigt__p_Fl_Check_Browser, _p_Fl_Check_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_Light_Button, _p_Fl_Light_ButtonTo_p_Fl_Button, 0, 0},  {&_swigt__p_Fl_Check_Button, _p_Fl_Check_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_Round_Button, _p_Fl_Round_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_Radio_Button, _p_Fl_Radio_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_Toggle_Button, _p_Fl_Toggle_ButtonTo_p_Fl_Button, 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},{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, _p_Fl_ClockTo_p_Fl_Clock_Output, 0, 0},  {&_swigt__p_Fl_Round_Clock, _p_Fl_Round_ClockTo_p_Fl_Clock_Output, 0, 0},  {&_swigt__p_Fl_Clock_Output, 0, 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_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_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_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_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_Float_Input[] = {  {&_swigt__p_Fl_Float_Input, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_FormsBitmap[] = {  {&_swigt__p_Fl_FormsBitmap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_FormsPixmap[] = {  {&_swigt__p_Fl_FormsPixmap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Free[] = {  {&_swigt__p_Fl_Free, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_GIF_Image[] = {  {&_swigt__p_Fl_GIF_Image, 0, 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_Group[] = {  {&_swigt__p_Fl_Text_Editor, _p_Fl_Text_EditorTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Menu_Window, _p_Fl_Menu_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Single_Window, _p_Fl_Single_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Gl_Window, _p_Fl_Gl_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Double_Window, _p_Fl_Double_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Window, _p_Fl_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Overlay_Window, _p_Fl_Overlay_WindowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Tile, _p_Fl_TileTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Color_Chooser, _p_Fl_Color_ChooserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Tabs, _p_Fl_TabsTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Wizard, _p_Fl_WizardTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Multi_Browser, _p_Fl_Multi_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Hold_Browser, _p_Fl_Hold_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Check_Browser, _p_Fl_Check_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_File_Browser, _p_Fl_File_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Browser, _p_Fl_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Select_Browser, _p_Fl_Select_BrowserTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Scroll, _p_Fl_ScrollTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Browser_, _p_Fl_Browser_To_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Table, _p_Fl_TableTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Help_View, _p_Fl_Help_ViewTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Pack, _p_Fl_PackTo_p_Fl_Group, 0, 0},  {&_swigt__p_ListSelect, _p_ListSelectTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Text_Display, _p_Fl_Text_DisplayTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Spinner, _p_Fl_SpinnerTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Group, 0, 0, 0},  {&_swigt__p_Fl_Table_Row, _p_Fl_Table_RowTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Input_Choice, _p_Fl_Input_ChoiceTo_p_Fl_Group, 0, 0},  {&_swigt__p_Fl_Tree, _p_Fl_TreeTo_p_Fl_Group, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Help_Block[] = {  {&_swigt__p_Fl_Help_Block, 0, 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_Font_Stack[] = {  {&_swigt__p_Fl_Help_Font_Stack, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Help_Font_Style[] = {  {&_swigt__p_Fl_Help_Font_Style, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Help_Link[] = {  {&_swigt__p_Fl_Help_Link, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Help_Target[] = {  {&_swigt__p_Fl_Help_Target, 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_Image[] = {  {&_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_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},  {&_swigt__p_Fl_Image, 0, 0, 0},  {&_swigt__p_Fl_RGB_Image, _p_Fl_RGB_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_BMP_Image, _p_Fl_BMP_ImageTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_GIF_Image, _p_Fl_GIF_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_Pixmap, _p_Fl_PixmapTo_p_Fl_Image, 0, 0},  {&_swigt__p_Fl_Bitmap, _p_Fl_BitmapTo_p_Fl_Image, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Input[] = {  {&_swigt__p_Fl_Output, _p_Fl_OutputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Multiline_Output, _p_Fl_Multiline_OutputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_File_Input, _p_Fl_File_InputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Multiline_Input, _p_Fl_Multiline_InputTo_p_Fl_Input, 0, 0},  {&_swigt__p_Fl_Input, 0, 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_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_Output, _p_Fl_OutputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Multiline_Output, _p_Fl_Multiline_OutputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_File_Input, _p_Fl_File_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Multiline_Input, _p_Fl_Multiline_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Input, _p_Fl_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_Secret_Input, _p_Fl_Secret_InputTo_p_Fl_Input_, 0, 0},  {&_swigt__p_Fl_Input_, 0, 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_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_Round_Button, _p_Fl_Round_ButtonTo_p_Fl_Light_Button, 0, 0},  {&_swigt__p_Fl_Radio_Round_Button, _p_Fl_Radio_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_Bar, _p_Fl_Menu_BarTo_p_Fl_Menu_, 0, 0},  {&_swigt__p_Fl_Menu_, 0, 0, 0},  {&_swigt__p_Fl_Choice, _p_Fl_ChoiceTo_p_Fl_Menu_, 0, 0},  {&_swigt__p_Fl_Menu_Button, _p_Fl_Menu_ButtonTo_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},{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_Nice_Slider[] = {  {&_swigt__p_Fl_Nice_Slider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Option[] = {  {&_swigt__p_Fl_Option, 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_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_Printer, _p_Fl_PrinterTo_p_Fl_Paged_Device, 0, 0},  {&_swigt__p_Fl_Paged_Device, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Pixmap[] = {  {&_swigt__p_Fl_XPM_Image, _p_Fl_XPM_ImageTo_p_Fl_Pixmap, 0, 0},  {&_swigt__p_Fl_GIF_Image, _p_Fl_GIF_ImageTo_p_Fl_Pixmap, 0, 0},  {&_swigt__p_Fl_Pixmap, 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_Preferences[] = {  {&_swigt__p_Fl_Preferences, 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_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_RGB_Image, 0, 0, 0},  {&_swigt__p_Fl_BMP_Image, _p_Fl_BMP_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_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_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_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_Scrollbar, _p_Fl_ScrollbarTo_p_Fl_Slider, 0, 0},  {&_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_Value_Slider, _p_Fl_Value_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},{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_Table[] = {  {&_swigt__p_Fl_Table_Row, _p_Fl_Table_RowTo_p_Fl_Table, 0, 0},  {&_swigt__p_Fl_Table, 0, 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_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_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_Timer[] = {  {&_swigt__p_Fl_Timer, 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_Adjuster, _p_Fl_AdjusterTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Flcc_Value_Input, _p_Flcc_Value_InputTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Value_Input, _p_Fl_Value_InputTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Fill_Dial, _p_Fl_Fill_DialTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Dial, _p_Fl_DialTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Counter, _p_Fl_CounterTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Simple_Counter, _p_Fl_Simple_CounterTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Line_Dial, _p_Fl_Line_DialTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Value_Output, _p_Fl_Value_OutputTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Hor_Value_Slider, _p_Fl_Hor_Value_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Value_Slider, _p_Fl_Value_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Hor_Slider, _p_Fl_Hor_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_Fill_Slider, _p_Fl_Hor_Fill_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Fill_Slider, _p_Fl_Fill_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Slider, _p_Fl_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Nice_Slider, _p_Fl_Nice_SliderTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Scrollbar, _p_Fl_ScrollbarTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Roller, _p_Fl_RollerTo_p_Fl_Valuator, 0, 0},  {&_swigt__p_Fl_Valuator, 0, 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_Widget[] = {  {&_swigt__p_Fl_Tree, _p_Fl_TreeTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Table, _p_Fl_TableTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Free, _p_Fl_FreeTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_Bar, _p_Fl_Menu_BarTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Positioner, _p_Fl_PositionerTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Group, _p_Fl_GroupTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Tile, _p_Fl_TileTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Text_Display, _p_Fl_Text_DisplayTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Nice_Slider, _p_Fl_Nice_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_Value_Slider, _p_Fl_Value_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Hor_Slider, _p_Fl_Hor_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_Fill_Slider, _p_Fl_Hor_Fill_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Fill_Slider, _p_Fl_Fill_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Slider, _p_Fl_SliderTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Valuator, _p_Fl_ValuatorTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Timer, _p_Fl_TimerTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Chart, _p_Fl_ChartTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Fill_Dial, _p_Fl_Fill_DialTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Dial, _p_Fl_DialTo_p_Fl_Widget, 0, 0},  {&_swigt__p_ListSelect, _p_ListSelectTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Float_Input, _p_Fl_Float_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Input, _p_Fl_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Int_Input, _p_Fl_Int_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Secret_Input, _p_Fl_Secret_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_Button, _p_Fl_Menu_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Return_Button, _p_Fl_Return_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Repeat_Button, _p_Fl_Repeat_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Radio_Button, _p_Fl_Radio_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_Round_Button, _p_Fl_Round_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_Check_Button, _p_Fl_Check_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Light_Button, _p_Fl_Light_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Button, _p_Fl_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Toggle_Button, _p_Fl_Toggle_ButtonTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Counter, _p_Fl_CounterTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Simple_Counter, _p_Fl_Simple_CounterTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Hold_Browser, _p_Fl_Hold_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Multi_Browser, _p_Fl_Multi_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Check_Browser, _p_Fl_Check_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_File_Browser, _p_Fl_File_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Browser, _p_Fl_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Select_Browser, _p_Fl_Select_BrowserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Multiline_Output, _p_Fl_Multiline_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Output, _p_Fl_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Value_Output, _p_Fl_Value_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Clock_Output, _p_Fl_Clock_OutputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Flcc_ValueBox, _p_Flcc_ValueBoxTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Box, _p_Fl_BoxTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Flcc_HueBox, _p_Flcc_HueBoxTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Widget, 0, 0, 0},  {&_swigt__p_Fl_Scrollbar, _p_Fl_ScrollbarTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Single_Window, _p_Fl_Single_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Gl_Window, _p_Fl_Gl_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Double_Window, _p_Fl_Double_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Window, _p_Fl_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Overlay_Window, _p_Fl_Overlay_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_Window, _p_Fl_Menu_WindowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Menu_, _p_Fl_Menu_To_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_FormsBitmap, _p_Fl_FormsBitmapTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Scroll, _p_Fl_ScrollTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Multiline_Input, _p_Fl_Multiline_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_File_Input, _p_Fl_File_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Flcc_Value_Input, _p_Flcc_Value_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Value_Input, _p_Fl_Value_InputTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Tabs, _p_Fl_TabsTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Adjuster, _p_Fl_AdjusterTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Clock, _p_Fl_ClockTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Round_Clock, _p_Fl_Round_ClockTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Input_, _p_Fl_Input_To_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Text_Editor, _p_Fl_Text_EditorTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Browser_, _p_Fl_Browser_To_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_FormsPixmap, _p_Fl_FormsPixmapTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Help_View, _p_Fl_Help_ViewTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Line_Dial, _p_Fl_Line_DialTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Progress, _p_Fl_ProgressTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Pack, _p_Fl_PackTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Spinner, _p_Fl_SpinnerTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Table_Row, _p_Fl_Table_RowTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Color_Chooser, _p_Fl_Color_ChooserTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Roller, _p_Fl_RollerTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Input_Choice, _p_Fl_Input_ChoiceTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Choice, _p_Fl_ChoiceTo_p_Fl_Widget, 0, 0},  {&_swigt__p_Fl_Wizard, _p_Fl_WizardTo_p_Fl_Widget, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fl_Widget_Tracker[] = {  {&_swigt__p_Fl_Widget_Tracker, 0, 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_Overlay_Window, _p_Fl_Overlay_WindowTo_p_Fl_Window, 0, 0},  {&_swigt__p_Fl_Gl_Window, _p_Fl_Gl_WindowTo_p_Fl_Window, 0, 0},  {&_swigt__p_Fl_Single_Window, _p_Fl_Single_WindowTo_p_Fl_Window, 0, 0},  {&_swigt__p_Fl_Menu_Window, _p_Fl_Menu_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_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_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_ListSelect[] = {  {&_swigt__p_ListSelect, 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_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___void[] = {  {&_swigt__p_f___void, 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_int_int_unsigned_int__void[] = {  {&_swigt__p_f_int_int_int_int_unsigned_int__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_int_p_Fl_Window__int[] = {  {&_swigt__p_f_int_p_Fl_Window__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_p_p_char_r_int__int[] = {  {&_swigt__p_f_int_p_p_char_r_int__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_p_void__void[] = {  {&_swigt__p_f_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_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_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_int_float_float_char__int[] = {  {&_swigt__p_f_p_Fl_Widget_int_float_float_char__int, 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_Fl_Window_p_void__void[] = {  {&_swigt__p_f_p_Fl_Window_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void[] = {  {&_swigt__p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__Fl_Label_r_int_r_int__void[] = {  {&_swigt__p_f_p_q_const__Fl_Label_r_int_r_int__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_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_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_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_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_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_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_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_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_Image[] = {  {&_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_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},  {&_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_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_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_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_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_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_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},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_v_______void[] = {  {&_swigt__p_f_p_q_const__char_v_______void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__void[] = {  {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_int_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_p_void_p_void__int[] = {  {&_swigt__p_f_p_void_p_void__int, 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_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_long[] = {  {&_swigt__p_long, 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_BMP_Image[] = {{&_swigt__p_p_Fl_BMP_Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_RGB_Image[] = {  {&_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_RGB_Image, 0, 0, 0},  {&_swigt__p_p_Fl_BMP_Image, _p_p_Fl_BMP_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_Tree[] = {{&_swigt__p_p_Fl_Tree, 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_Free[] = {{&_swigt__p_p_Fl_Free, 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_Positioner[] = {{&_swigt__p_p_Fl_Positioner, 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_Tile[] = {{&_swigt__p_p_Fl_Tile, 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_Value_Slider[] = {{&_swigt__p_p_Fl_Value_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_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_Fill_Slider[] = {{&_swigt__p_p_Fl_Hor_Fill_Slider, 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_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_Nice_Slider[] = {{&_swigt__p_p_Fl_Nice_Slider, 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_Valuator[] = {{&_swigt__p_p_Fl_Valuator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Timer[] = {{&_swigt__p_p_Fl_Timer, 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_Dial[] = {{&_swigt__p_p_Fl_Dial, 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_ListSelect[] = {{&_swigt__p_p_ListSelect, 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_Int_Input[] = {{&_swigt__p_p_Fl_Int_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_Float_Input[] = {{&_swigt__p_p_Fl_Float_Input, 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_Menu_Button[] = {{&_swigt__p_p_Fl_Menu_Button, 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_Toggle_Button[] = {{&_swigt__p_p_Fl_Toggle_Button, 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_Light_Button[] = {{&_swigt__p_p_Fl_Light_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_Repeat_Button[] = {{&_swigt__p_p_Fl_Repeat_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_Round_Button[] = {{&_swigt__p_p_Fl_Round_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_Counter[] = {{&_swigt__p_p_Fl_Counter, 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_Multi_Browser[] = {{&_swigt__p_p_Fl_Multi_Browser, 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_Check_Browser[] = {{&_swigt__p_p_Fl_Check_Browser, 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_Browser[] = {{&_swigt__p_p_Fl_Browser, 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_Output[] = {{&_swigt__p_p_Fl_Output, 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_Value_Output[] = {{&_swigt__p_p_Fl_Value_Output, 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_Fl_Box[] = {{&_swigt__p_p_Fl_Box, 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_Fl_Scrollbar[] = {{&_swigt__p_p_Fl_Scrollbar, 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_Menu_Window[] = {{&_swigt__p_p_Fl_Menu_Window, 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_Gl_Window[] = {{&_swigt__p_p_Fl_Gl_Window, 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_Double_Window[] = {{&_swigt__p_p_Fl_Double_Window, 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_FormsBitmap[] = {{&_swigt__p_p_Fl_FormsBitmap, 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_Multiline_Input[] = {{&_swigt__p_p_Fl_Multiline_Input, 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_Flcc_Value_Input[] = {{&_swigt__p_p_Flcc_Value_Input, 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_Tabs[] = {{&_swigt__p_p_Fl_Tabs, 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_Adjuster[] = {{&_swigt__p_p_Fl_Adjuster, 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_Clock[] = {{&_swigt__p_p_Fl_Clock, 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_FormsPixmap[] = {{&_swigt__p_p_Fl_FormsPixmap, 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_Help_View[] = {{&_swigt__p_p_Fl_Help_View, 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_Line_Dial[] = {{&_swigt__p_p_Fl_Line_Dial, 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_Spinner[] = {{&_swigt__p_p_Fl_Spinner, 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_Color_Chooser[] = {{&_swigt__p_p_Fl_Color_Chooser, 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_Input_Choice[] = {{&_swigt__p_p_Fl_Input_Choice, 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_Wizard[] = {{&_swigt__p_p_Fl_Wizard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Fl_Widget[] = {  {&_swigt__p_p_Fl_Tree, _p_p_Fl_TreeTo_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_Free, _p_p_Fl_FreeTo_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_Positioner, _p_p_Fl_PositionerTo_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_Tile, _p_p_Fl_TileTo_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_Value_Slider, _p_p_Fl_Value_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_Nice_Slider, _p_p_Fl_Hor_Nice_SliderTo_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_Slider, _p_p_Fl_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_Nice_Slider, _p_p_Fl_Nice_SliderTo_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_Valuator, _p_p_Fl_ValuatorTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Timer, _p_p_Fl_TimerTo_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_Dial, _p_p_Fl_DialTo_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_ListSelect, _p_p_ListSelectTo_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_Int_Input, _p_p_Fl_Int_InputTo_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_Float_Input, _p_p_Fl_Float_InputTo_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_Menu_Button, _p_p_Fl_Menu_ButtonTo_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_Toggle_Button, _p_p_Fl_Toggle_ButtonTo_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_Light_Button, _p_p_Fl_Light_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_Repeat_Button, _p_p_Fl_Repeat_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_Round_Button, _p_p_Fl_Round_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_Counter, _p_p_Fl_CounterTo_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_Multi_Browser, _p_p_Fl_Multi_BrowserTo_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_Check_Browser, _p_p_Fl_Check_BrowserTo_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_Browser, _p_p_Fl_BrowserTo_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_Output, _p_p_Fl_OutputTo_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_Value_Output, _p_p_Fl_Value_OutputTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Flcc_ValueBox, _p_p_Flcc_ValueBoxTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Box, _p_p_Fl_BoxTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Flcc_HueBox, _p_p_Flcc_HueBoxTo_p_p_Fl_Widget, 0, 0},  {&_swigt__p_p_Fl_Widget, 0, 0, 0},  {&_swigt__p_p_Fl_Scrollbar, _p_p_Fl_ScrollbarTo_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_Menu_Window, _p_p_Fl_Menu_WindowTo_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_Gl_Window, _p_p_Fl_Gl_WindowTo_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_Double_Window, _p_p_Fl_Double_WindowTo_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_FormsBitmap, _p_p_Fl_FormsBitmapTo_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_Multiline_Input, _p_p_Fl_Multiline_InputTo_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_Flcc_Value_Input, _p_p_Flcc_Value_InputTo_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_Tabs, _p_p_Fl_TabsTo_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_Adjuster, _p_p_Fl_AdjusterTo_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_Clock, _p_p_Fl_ClockTo_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_FormsPixmap, _p_p_Fl_FormsPixmapTo_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_Help_View, _p_p_Fl_Help_ViewTo_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_Line_Dial, _p_p_Fl_Line_DialTo_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_Spinner, _p_p_Fl_SpinnerTo_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_Color_Chooser, _p_p_Fl_Color_ChooserTo_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_Input_Choice, _p_p_Fl_Input_ChoiceTo_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_Wizard, _p_p_Fl_WizardTo_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_dirent[] = {  {&_swigt__p_p_p_dirent, 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_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 *swig_cast_initial[] = {
  _swigc__p_FILE,
  _swigc__p_FL_CHART_ENTRY,
  _swigc__p_Fl,
  _swigc__p_Fl_Adjuster,
  _swigc__p_Fl_BMP_Image,
  _swigc__p_Fl_Bitmap,
  _swigc__p_Fl_Box,
  _swigc__p_Fl_Browser,
  _swigc__p_Fl_Browser_,
  _swigc__p_Fl_Button,
  _swigc__p_Fl_Chart,
  _swigc__p_Fl_Check_Browser,
  _swigc__p_Fl_Check_Button,
  _swigc__p_Fl_Choice,
  _swigc__p_Fl_Clock,
  _swigc__p_Fl_Clock_Output,
  _swigc__p_Fl_Color_Chooser,
  _swigc__p_Fl_Counter,
  _swigc__p_Fl_Dial,
  _swigc__p_Fl_Double_Window,
  _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_Float_Input,
  _swigc__p_Fl_FormsBitmap,
  _swigc__p_Fl_FormsPixmap,
  _swigc__p_Fl_Free,
  _swigc__p_Fl_GIF_Image,
  _swigc__p_Fl_Gl_Window,
  _swigc__p_Fl_Graphics_Driver,
  _swigc__p_Fl_Group,
  _swigc__p_Fl_Help_Block,
  _swigc__p_Fl_Help_Dialog,
  _swigc__p_Fl_Help_Font_Stack,
  _swigc__p_Fl_Help_Font_Style,
  _swigc__p_Fl_Help_Link,
  _swigc__p_Fl_Help_Target,
  _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_Image,
  _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_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_Nice_Slider,
  _swigc__p_Fl_Option,
  _swigc__p_Fl_Output,
  _swigc__p_Fl_Overlay_Window,
  _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_Positioner,
  _swigc__p_Fl_Preferences,
  _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_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_Scroll,
  _swigc__p_Fl_Scrollbar,
  _swigc__p_Fl_Secret_Input,
  _swigc__p_Fl_Select_Browser,
  _swigc__p_Fl_Shared_Image,
  _swigc__p_Fl_Simple_Counter,
  _swigc__p_Fl_Single_Window,
  _swigc__p_Fl_Slider,
  _swigc__p_Fl_Spinner,
  _swigc__p_Fl_Table,
  _swigc__p_Fl_Table_Row,
  _swigc__p_Fl_Tabs,
  _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_Selection,
  _swigc__p_Fl_Tile,
  _swigc__p_Fl_Tiled_Image,
  _swigc__p_Fl_Timer,
  _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_Widget,
  _swigc__p_Fl_Widget_Tracker,
  _swigc__p_Fl_Window,
  _swigc__p_Fl_Wizard,
  _swigc__p_Fl_XBM_Image,
  _swigc__p_Fl_XPM_Image,
  _swigc__p_Flcc_HueBox,
  _swigc__p_Flcc_ValueBox,
  _swigc__p_Flcc_Value_Input,
  _swigc__p_ListSelect,
  _swigc__p_Style_Table_Entry,
  _swigc__p_char,
  _swigc__p_double,
  _swigc__p_f___void,
  _swigc__p_f_int_int_int_int_p_q_const__char_p_void__void,
  _swigc__p_f_int_int_int_int_unsigned_int__void,
  _swigc__p_f_int_int_p_void__void,
  _swigc__p_f_int_p_Fl_Text_Editor__int,
  _swigc__p_f_int_p_Fl_Window__int,
  _swigc__p_f_int_p_p_char_r_int__int,
  _swigc__p_f_int_p_void__void,
  _swigc__p_f_p_Fl_File_Chooser_p_void__void,
  _swigc__p_f_p_Fl_Widget__void,
  _swigc__p_f_p_Fl_Widget_int_float_float_char__int,
  _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_Fl_Window_p_void__void,
  _swigc__p_f_p_q_const__Fl_Label_int_int_int_int_unsigned_int__void,
  _swigc__p_f_p_q_const__Fl_Label_r_int_r_int__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_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_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_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_q_const__char_v_______void,
  _swigc__p_f_p_void__void,
  _swigc__p_f_p_void_int_int_int_int__void,
  _swigc__p_f_p_void_p_void__int,
  _swigc__p_f_unsigned_int__void,
  _swigc__p_float,
  _swigc__p_int,
  _swigc__p_long,
  _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_Float_Input,
  _swigc__p_p_Fl_FormsBitmap,
  _swigc__p_p_Fl_FormsPixmap,
  _swigc__p_p_Fl_Free,
  _swigc__p_p_Fl_Gl_Window,
  _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_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_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_Simple_Counter,
  _swigc__p_p_Fl_Single_Window,
  _swigc__p_p_Fl_Slider,
  _swigc__p_p_Fl_Spinner,
  _swigc__p_p_Fl_Table,
  _swigc__p_p_Fl_Table_Row,
  _swigc__p_p_Fl_Tabs,
  _swigc__p_p_Fl_Text_Display,
  _swigc__p_p_Fl_Text_Editor,
  _swigc__p_p_Fl_Tile,
  _swigc__p_p_Fl_Timer,
  _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_dirent,
  _swigc__p_short,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_unsigned_short,
  _swigc__p_void,
  _swigc__p_wchar_t,
};


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

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is 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


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int found, 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);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out 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 %d\n", 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 %d %s\n", 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 %d %s\n", 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
  
  /* 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(swig_varlinkobject *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(swig_varlinkobject *v) {
#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);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    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 int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    char *tmp;
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(str);
    return 0;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    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(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
        /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        (char *)"swigvarlink",              /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        (printfunc) swig_varlink_print,     /* tp_print */
        (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 */
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
        0,                                  /* tp_version */
#endif
#ifdef COUNT_ALLOCS
        0,0,0,0                             /* tp_alloc -> tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
#if PY_VERSION_HEX < 0x02020000
      varlink_type.ob_type = &PyType_Type;
#else
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
#endif
    }
    return &varlink_type;
  }
  
  /* 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, 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) {
        strncpy(gv->name,name,size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *_SWIG_globals = 0; 
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
    return _SWIG_globals;
  }
  
  /* -----------------------------------------------------------------------------
   * 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);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    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 && (c = strstr(c, "swig_ptr: "))) {
        int j;
        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;
              strncpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              strncpy(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;
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
    PyModuleDef_HEAD_INIT,
# else
    {
      PyObject_HEAD_INIT(NULL)
      NULL, /* m_init */
      0,    /* m_index */
      NULL, /* m_copy */
    },
# endif
    (char *) 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 = {
    (PyCFunction) SwigPyObject_own,
    (PyCFunction) SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyObject *metatype_args;
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  
  /* metatype is used to implement static member variables. */
  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
  assert(metatype_args);
  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
  assert(metatype);
  Py_DECREF(metatype_args);
  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
  assert(PyType_Ready(metatype) >= 0);
#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((char *) SWIG_name, SwigMethods);
#endif
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  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_TypeOnce();
  } else if (SwigPyObject_TypeOnce()->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);
  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_MAJOR_VERSION",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_MINOR_VERSION",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_PATCH_VERSION",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "FL_API_VERSION",SWIG_From_int(static_cast< int >((1*10000+3*100+4))));
  SWIG_Python_SetConstant(d, "FL_ABI_VERSION",SWIG_From_int(static_cast< int >((1*10000+3*100))));
  SWIG_Python_SetConstant(d, "FLTK_ABI_VERSION",SWIG_From_int(static_cast< int >((1*10000+3*100))));
  SWIG_Python_SetConstant(d, "FL_NO_EVENT",SWIG_From_int(static_cast< int >(FL_NO_EVENT)));
  SWIG_Python_SetConstant(d, "FL_PUSH",SWIG_From_int(static_cast< int >(FL_PUSH)));
  SWIG_Python_SetConstant(d, "FL_RELEASE",SWIG_From_int(static_cast< int >(FL_RELEASE)));
  SWIG_Python_SetConstant(d, "FL_ENTER",SWIG_From_int(static_cast< int >(FL_ENTER)));
  SWIG_Python_SetConstant(d, "FL_LEAVE",SWIG_From_int(static_cast< int >(FL_LEAVE)));
  SWIG_Python_SetConstant(d, "FL_DRAG",SWIG_From_int(static_cast< int >(FL_DRAG)));
  SWIG_Python_SetConstant(d, "FL_FOCUS",SWIG_From_int(static_cast< int >(FL_FOCUS)));
  SWIG_Python_SetConstant(d, "FL_UNFOCUS",SWIG_From_int(static_cast< int >(FL_UNFOCUS)));
  SWIG_Python_SetConstant(d, "FL_KEYDOWN",SWIG_From_int(static_cast< int >(FL_KEYDOWN)));
  SWIG_Python_SetConstant(d, "FL_KEYBOARD",SWIG_From_int(static_cast< int >(FL_KEYBOARD)));
  SWIG_Python_SetConstant(d, "FL_KEYUP",SWIG_From_int(static_cast< int >(FL_KEYUP)));
  SWIG_Python_SetConstant(d, "FL_CLOSE",SWIG_From_int(static_cast< int >(FL_CLOSE)));
  SWIG_Python_SetConstant(d, "FL_MOVE",SWIG_From_int(static_cast< int >(FL_MOVE)));
  SWIG_Python_SetConstant(d, "FL_SHORTCUT",SWIG_From_int(static_cast< int >(FL_SHORTCUT)));
  SWIG_Python_SetConstant(d, "FL_DEACTIVATE",SWIG_From_int(static_cast< int >(FL_DEACTIVATE)));
  SWIG_Python_SetConstant(d, "FL_ACTIVATE",SWIG_From_int(static_cast< int >(FL_ACTIVATE)));
  SWIG_Python_SetConstant(d, "FL_HIDE",SWIG_From_int(static_cast< int >(FL_HIDE)));
  SWIG_Python_SetConstant(d, "FL_SHOW",SWIG_From_int(static_cast< int >(FL_SHOW)));
  SWIG_Python_SetConstant(d, "FL_PASTE",SWIG_From_int(static_cast< int >(FL_PASTE)));
  SWIG_Python_SetConstant(d, "FL_SELECTIONCLEAR",SWIG_From_int(static_cast< int >(FL_SELECTIONCLEAR)));
  SWIG_Python_SetConstant(d, "FL_MOUSEWHEEL",SWIG_From_int(static_cast< int >(FL_MOUSEWHEEL)));
  SWIG_Python_SetConstant(d, "FL_DND_ENTER",SWIG_From_int(static_cast< int >(FL_DND_ENTER)));
  SWIG_Python_SetConstant(d, "FL_DND_DRAG",SWIG_From_int(static_cast< int >(FL_DND_DRAG)));
  SWIG_Python_SetConstant(d, "FL_DND_LEAVE",SWIG_From_int(static_cast< int >(FL_DND_LEAVE)));
  SWIG_Python_SetConstant(d, "FL_DND_RELEASE",SWIG_From_int(static_cast< int >(FL_DND_RELEASE)));
  SWIG_Python_SetConstant(d, "FL_SCREEN_CONFIGURATION_CHANGED",SWIG_From_int(static_cast< int >(FL_SCREEN_CONFIGURATION_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_FULLSCREEN",SWIG_From_int(static_cast< int >(FL_FULLSCREEN)));
  SWIG_Python_SetConstant(d, "FL_ZOOM_GESTURE",SWIG_From_int(static_cast< int >(FL_ZOOM_GESTURE)));
  SWIG_Python_SetConstant(d, "FL_WHEN_NEVER",SWIG_From_int(static_cast< int >(FL_WHEN_NEVER)));
  SWIG_Python_SetConstant(d, "FL_WHEN_CHANGED",SWIG_From_int(static_cast< int >(FL_WHEN_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_WHEN_NOT_CHANGED",SWIG_From_int(static_cast< int >(FL_WHEN_NOT_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_WHEN_RELEASE",SWIG_From_int(static_cast< int >(FL_WHEN_RELEASE)));
  SWIG_Python_SetConstant(d, "FL_WHEN_RELEASE_ALWAYS",SWIG_From_int(static_cast< int >(FL_WHEN_RELEASE_ALWAYS)));
  SWIG_Python_SetConstant(d, "FL_WHEN_ENTER_KEY",SWIG_From_int(static_cast< int >(FL_WHEN_ENTER_KEY)));
  SWIG_Python_SetConstant(d, "FL_WHEN_ENTER_KEY_ALWAYS",SWIG_From_int(static_cast< int >(FL_WHEN_ENTER_KEY_ALWAYS)));
  SWIG_Python_SetConstant(d, "FL_WHEN_ENTER_KEY_CHANGED",SWIG_From_int(static_cast< int >(FL_WHEN_ENTER_KEY_CHANGED)));
  SWIG_Python_SetConstant(d, "FL_Button",SWIG_From_int(static_cast< int >(0xfee8)));
  SWIG_Python_SetConstant(d, "FL_BackSpace",SWIG_From_int(static_cast< int >(0xff08)));
  SWIG_Python_SetConstant(d, "FL_Tab",SWIG_From_int(static_cast< int >(0xff09)));
  SWIG_Python_SetConstant(d, "FL_Iso_Key",SWIG_From_int(static_cast< int >(0xff0c)));
  SWIG_Python_SetConstant(d, "FL_Enter",SWIG_From_int(static_cast< int >(0xff0d)));
  SWIG_Python_SetConstant(d, "FL_Pause",SWIG_From_int(static_cast< int >(0xff13)));
  SWIG_Python_SetConstant(d, "FL_Scroll_Lock",SWIG_From_int(static_cast< int >(0xff14)));
  SWIG_Python_SetConstant(d, "FL_Escape",SWIG_From_int(static_cast< int >(0xff1b)));
  SWIG_Python_SetConstant(d, "FL_Kana",SWIG_From_int(static_cast< int >(0xff2e)));
  SWIG_Python_SetConstant(d, "FL_Eisu",SWIG_From_int(static_cast< int >(0xff2f)));
  SWIG_Python_SetConstant(d, "FL_Yen",SWIG_From_int(static_cast< int >(0xff30)));
  SWIG_Python_SetConstant(d, "FL_JIS_Underscore",SWIG_From_int(static_cast< int >(0xff31)));
  SWIG_Python_SetConstant(d, "FL_Home",SWIG_From_int(static_cast< int >(0xff50)));
  SWIG_Python_SetConstant(d, "FL_Left",SWIG_From_int(static_cast< int >(0xff51)));
  SWIG_Python_SetConstant(d, "FL_Up",SWIG_From_int(static_cast< int >(0xff52)));
  SWIG_Python_SetConstant(d, "FL_Right",SWIG_From_int(static_cast< int >(0xff53)));
  SWIG_Python_SetConstant(d, "FL_Down",SWIG_From_int(static_cast< int >(0xff54)));
  SWIG_Python_SetConstant(d, "FL_Page_Up",SWIG_From_int(static_cast< int >(0xff55)));
  SWIG_Python_SetConstant(d, "FL_Page_Down",SWIG_From_int(static_cast< int >(0xff56)));
  SWIG_Python_SetConstant(d, "FL_End",SWIG_From_int(static_cast< int >(0xff57)));
  SWIG_Python_SetConstant(d, "FL_Print",SWIG_From_int(static_cast< int >(0xff61)));
  SWIG_Python_SetConstant(d, "FL_Insert",SWIG_From_int(static_cast< int >(0xff63)));
  SWIG_Python_SetConstant(d, "FL_Menu",SWIG_From_int(static_cast< int >(0xff67)));
  SWIG_Python_SetConstant(d, "FL_Help",SWIG_From_int(static_cast< int >(0xff68)));
  SWIG_Python_SetConstant(d, "FL_Num_Lock",SWIG_From_int(static_cast< int >(0xff7f)));
  SWIG_Python_SetConstant(d, "FL_KP",SWIG_From_int(static_cast< int >(0xff80)));
  SWIG_Python_SetConstant(d, "FL_KP_Enter",SWIG_From_int(static_cast< int >(0xff8d)));
  SWIG_Python_SetConstant(d, "FL_KP_Last",SWIG_From_int(static_cast< int >(0xffbd)));
  SWIG_Python_SetConstant(d, "FL_F",SWIG_From_int(static_cast< int >(0xffbd)));
  SWIG_Python_SetConstant(d, "FL_F_Last",SWIG_From_int(static_cast< int >(0xffe0)));
  SWIG_Python_SetConstant(d, "FL_Shift_L",SWIG_From_int(static_cast< int >(0xffe1)));
  SWIG_Python_SetConstant(d, "FL_Shift_R",SWIG_From_int(static_cast< int >(0xffe2)));
  SWIG_Python_SetConstant(d, "FL_Control_L",SWIG_From_int(static_cast< int >(0xffe3)));
  SWIG_Python_SetConstant(d, "FL_Control_R",SWIG_From_int(static_cast< int >(0xffe4)));
  SWIG_Python_SetConstant(d, "FL_Caps_Lock",SWIG_From_int(static_cast< int >(0xffe5)));
  SWIG_Python_SetConstant(d, "FL_Meta_L",SWIG_From_int(static_cast< int >(0xffe7)));
  SWIG_Python_SetConstant(d, "FL_Meta_R",SWIG_From_int(static_cast< int >(0xffe8)));
  SWIG_Python_SetConstant(d, "FL_Alt_L",SWIG_From_int(static_cast< int >(0xffe9)));
  SWIG_Python_SetConstant(d, "FL_Alt_R",SWIG_From_int(static_cast< int >(0xffea)));
  SWIG_Python_SetConstant(d, "FL_Delete",SWIG_From_int(static_cast< int >(0xffff)));
  SWIG_Python_SetConstant(d, "FL_Volume_Down",SWIG_From_int(static_cast< int >(0xEF11)));
  SWIG_Python_SetConstant(d, "FL_Volume_Mute",SWIG_From_int(static_cast< int >(0xEF12)));
  SWIG_Python_SetConstant(d, "FL_Volume_Up",SWIG_From_int(static_cast< int >(0xEF13)));
  SWIG_Python_SetConstant(d, "FL_Media_Play",SWIG_From_int(static_cast< int >(0xEF14)));
  SWIG_Python_SetConstant(d, "FL_Media_Stop",SWIG_From_int(static_cast< int >(0xEF15)));
  SWIG_Python_SetConstant(d, "FL_Media_Prev",SWIG_From_int(static_cast< int >(0xEF16)));
  SWIG_Python_SetConstant(d, "FL_Media_Next",SWIG_From_int(static_cast< int >(0xEF17)));
  SWIG_Python_SetConstant(d, "FL_Home_Page",SWIG_From_int(static_cast< int >(0xEF18)));
  SWIG_Python_SetConstant(d, "FL_Mail",SWIG_From_int(static_cast< int >(0xEF19)));
  SWIG_Python_SetConstant(d, "FL_Search",SWIG_From_int(static_cast< int >(0xEF1B)));
  SWIG_Python_SetConstant(d, "FL_Back",SWIG_From_int(static_cast< int >(0xEF26)));
  SWIG_Python_SetConstant(d, "FL_Forward",SWIG_From_int(static_cast< int >(0xEF27)));
  SWIG_Python_SetConstant(d, "FL_Stop",SWIG_From_int(static_cast< int >(0xEF28)));
  SWIG_Python_SetConstant(d, "FL_Refresh",SWIG_From_int(static_cast< int >(0xEF29)));
  SWIG_Python_SetConstant(d, "FL_Sleep",SWIG_From_int(static_cast< int >(0xEF2F)));
  SWIG_Python_SetConstant(d, "FL_Favorites",SWIG_From_int(static_cast< int >(0xEF30)));
  SWIG_Python_SetConstant(d, "FL_LEFT_MOUSE",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_MIDDLE_MOUSE",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_RIGHT_MOUSE",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_SHIFT",SWIG_From_int(static_cast< int >(0x00010000)));
  SWIG_Python_SetConstant(d, "FL_CAPS_LOCK",SWIG_From_int(static_cast< int >(0x00020000)));
  SWIG_Python_SetConstant(d, "FL_CTRL",SWIG_From_int(static_cast< int >(0x00040000)));
  SWIG_Python_SetConstant(d, "FL_ALT",SWIG_From_int(static_cast< int >(0x00080000)));
  SWIG_Python_SetConstant(d, "FL_NUM_LOCK",SWIG_From_int(static_cast< int >(0x00100000)));
  SWIG_Python_SetConstant(d, "FL_META",SWIG_From_int(static_cast< int >(0x00400000)));
  SWIG_Python_SetConstant(d, "FL_SCROLL_LOCK",SWIG_From_int(static_cast< int >(0x00800000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON1",SWIG_From_int(static_cast< int >(0x01000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON2",SWIG_From_int(static_cast< int >(0x02000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTON3",SWIG_From_int(static_cast< int >(0x04000000)));
  SWIG_Python_SetConstant(d, "FL_BUTTONS",SWIG_From_int(static_cast< int >(0x7f000000)));
  SWIG_Python_SetConstant(d, "FL_KEY_MASK",SWIG_From_int(static_cast< int >(0x0000ffff)));
  SWIG_Python_SetConstant(d, "FL_COMMAND",SWIG_From_int(static_cast< int >(0x00040000)));
  SWIG_Python_SetConstant(d, "FL_CONTROL",SWIG_From_int(static_cast< int >(0x00400000)));
  SWIG_Python_SetConstant(d, "FL_NO_BOX",SWIG_From_int(static_cast< int >(FL_NO_BOX)));
  SWIG_Python_SetConstant(d, "FL_FLAT_BOX",SWIG_From_int(static_cast< int >(FL_FLAT_BOX)));
  SWIG_Python_SetConstant(d, "FL_UP_BOX",SWIG_From_int(static_cast< int >(FL_UP_BOX)));
  SWIG_Python_SetConstant(d, "FL_DOWN_BOX",SWIG_From_int(static_cast< int >(FL_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "FL_UP_FRAME",SWIG_From_int(static_cast< int >(FL_UP_FRAME)));
  SWIG_Python_SetConstant(d, "FL_DOWN_FRAME",SWIG_From_int(static_cast< int >(FL_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "FL_THIN_UP_BOX",SWIG_From_int(static_cast< int >(FL_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "FL_THIN_DOWN_BOX",SWIG_From_int(static_cast< int >(FL_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "FL_THIN_UP_FRAME",SWIG_From_int(static_cast< int >(FL_THIN_UP_FRAME)));
  SWIG_Python_SetConstant(d, "FL_THIN_DOWN_FRAME",SWIG_From_int(static_cast< int >(FL_THIN_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "FL_ENGRAVED_BOX",SWIG_From_int(static_cast< int >(FL_ENGRAVED_BOX)));
  SWIG_Python_SetConstant(d, "FL_EMBOSSED_BOX",SWIG_From_int(static_cast< int >(FL_EMBOSSED_BOX)));
  SWIG_Python_SetConstant(d, "FL_ENGRAVED_FRAME",SWIG_From_int(static_cast< int >(FL_ENGRAVED_FRAME)));
  SWIG_Python_SetConstant(d, "FL_EMBOSSED_FRAME",SWIG_From_int(static_cast< int >(FL_EMBOSSED_FRAME)));
  SWIG_Python_SetConstant(d, "FL_BORDER_BOX",SWIG_From_int(static_cast< int >(FL_BORDER_BOX)));
  SWIG_Python_SetConstant(d, "_FL_SHADOW_BOX",SWIG_From_int(static_cast< int >(_FL_SHADOW_BOX)));
  SWIG_Python_SetConstant(d, "FL_BORDER_FRAME",SWIG_From_int(static_cast< int >(FL_BORDER_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_SHADOW_FRAME",SWIG_From_int(static_cast< int >(_FL_SHADOW_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_ROUNDED_BOX",SWIG_From_int(static_cast< int >(_FL_ROUNDED_BOX)));
  SWIG_Python_SetConstant(d, "_FL_RSHADOW_BOX",SWIG_From_int(static_cast< int >(_FL_RSHADOW_BOX)));
  SWIG_Python_SetConstant(d, "_FL_ROUNDED_FRAME",SWIG_From_int(static_cast< int >(_FL_ROUNDED_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_RFLAT_BOX",SWIG_From_int(static_cast< int >(_FL_RFLAT_BOX)));
  SWIG_Python_SetConstant(d, "_FL_ROUND_UP_BOX",SWIG_From_int(static_cast< int >(_FL_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_ROUND_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_DIAMOND_UP_BOX",SWIG_From_int(static_cast< int >(_FL_DIAMOND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_DIAMOND_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_DIAMOND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OVAL_BOX",SWIG_From_int(static_cast< int >(_FL_OVAL_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OSHADOW_BOX",SWIG_From_int(static_cast< int >(_FL_OSHADOW_BOX)));
  SWIG_Python_SetConstant(d, "_FL_OVAL_FRAME",SWIG_From_int(static_cast< int >(_FL_OVAL_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_OFLAT_BOX",SWIG_From_int(static_cast< int >(_FL_OFLAT_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_UP_BOX",SWIG_From_int(static_cast< int >(_FL_PLASTIC_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_PLASTIC_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_UP_FRAME",SWIG_From_int(static_cast< int >(_FL_PLASTIC_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_DOWN_FRAME",SWIG_From_int(static_cast< int >(_FL_PLASTIC_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_THIN_UP_BOX",SWIG_From_int(static_cast< int >(_FL_PLASTIC_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_THIN_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_PLASTIC_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_ROUND_UP_BOX",SWIG_From_int(static_cast< int >(_FL_PLASTIC_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_PLASTIC_ROUND_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_PLASTIC_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_UP_BOX",SWIG_From_int(static_cast< int >(_FL_GTK_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_GTK_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_UP_FRAME",SWIG_From_int(static_cast< int >(_FL_GTK_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_DOWN_FRAME",SWIG_From_int(static_cast< int >(_FL_GTK_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_UP_BOX",SWIG_From_int(static_cast< int >(_FL_GTK_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_GTK_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_UP_FRAME",SWIG_From_int(static_cast< int >(_FL_GTK_THIN_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_THIN_DOWN_FRAME",SWIG_From_int(static_cast< int >(_FL_GTK_THIN_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GTK_ROUND_UP_BOX",SWIG_From_int(static_cast< int >(_FL_GTK_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GTK_ROUND_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_GTK_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_UP_BOX",SWIG_From_int(static_cast< int >(_FL_GLEAM_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_GLEAM_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_UP_FRAME",SWIG_From_int(static_cast< int >(_FL_GLEAM_UP_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_DOWN_FRAME",SWIG_From_int(static_cast< int >(_FL_GLEAM_DOWN_FRAME)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_THIN_UP_BOX",SWIG_From_int(static_cast< int >(_FL_GLEAM_THIN_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_THIN_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_GLEAM_THIN_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_ROUND_UP_BOX",SWIG_From_int(static_cast< int >(_FL_GLEAM_ROUND_UP_BOX)));
  SWIG_Python_SetConstant(d, "_FL_GLEAM_ROUND_DOWN_BOX",SWIG_From_int(static_cast< int >(_FL_GLEAM_ROUND_DOWN_BOX)));
  SWIG_Python_SetConstant(d, "FL_FREE_BOXTYPE",SWIG_From_int(static_cast< int >(FL_FREE_BOXTYPE)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_LABEL",SWIG_From_int(static_cast< int >(FL_NORMAL_LABEL)));
  SWIG_Python_SetConstant(d, "FL_NO_LABEL",SWIG_From_int(static_cast< int >(FL_NO_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_SHADOW_LABEL",SWIG_From_int(static_cast< int >(_FL_SHADOW_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_ENGRAVED_LABEL",SWIG_From_int(static_cast< int >(_FL_ENGRAVED_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_EMBOSSED_LABEL",SWIG_From_int(static_cast< int >(_FL_EMBOSSED_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_MULTI_LABEL",SWIG_From_int(static_cast< int >(_FL_MULTI_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_ICON_LABEL",SWIG_From_int(static_cast< int >(_FL_ICON_LABEL)));
  SWIG_Python_SetConstant(d, "_FL_IMAGE_LABEL",SWIG_From_int(static_cast< int >(_FL_IMAGE_LABEL)));
  SWIG_Python_SetConstant(d, "FL_FREE_LABELTYPE",SWIG_From_int(static_cast< int >(FL_FREE_LABELTYPE)));
  SWIG_Python_SetConstant(d, "FL_NUM_FREE_COLOR",SWIG_From_int(static_cast< int >(16)));
  SWIG_Python_SetConstant(d, "FL_NUM_GRAY",SWIG_From_int(static_cast< int >(24)));
  SWIG_Python_SetConstant(d, "FL_NUM_RED",SWIG_From_int(static_cast< int >(5)));
  SWIG_Python_SetConstant(d, "FL_NUM_GREEN",SWIG_From_int(static_cast< int >(8)));
  SWIG_Python_SetConstant(d, "FL_NUM_BLUE",SWIG_From_int(static_cast< int >(5)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(FL_CURSOR_DEFAULT)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_ARROW",SWIG_From_int(static_cast< int >(FL_CURSOR_ARROW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_CROSS",SWIG_From_int(static_cast< int >(FL_CURSOR_CROSS)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_WAIT",SWIG_From_int(static_cast< int >(FL_CURSOR_WAIT)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_INSERT",SWIG_From_int(static_cast< int >(FL_CURSOR_INSERT)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_HAND",SWIG_From_int(static_cast< int >(FL_CURSOR_HAND)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_HELP",SWIG_From_int(static_cast< int >(FL_CURSOR_HELP)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_MOVE",SWIG_From_int(static_cast< int >(FL_CURSOR_MOVE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NS",SWIG_From_int(static_cast< int >(FL_CURSOR_NS)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_WE",SWIG_From_int(static_cast< int >(FL_CURSOR_WE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NWSE",SWIG_From_int(static_cast< int >(FL_CURSOR_NWSE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NESW",SWIG_From_int(static_cast< int >(FL_CURSOR_NESW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_N",SWIG_From_int(static_cast< int >(FL_CURSOR_N)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NE",SWIG_From_int(static_cast< int >(FL_CURSOR_NE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_E",SWIG_From_int(static_cast< int >(FL_CURSOR_E)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_SE",SWIG_From_int(static_cast< int >(FL_CURSOR_SE)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_S",SWIG_From_int(static_cast< int >(FL_CURSOR_S)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_SW",SWIG_From_int(static_cast< int >(FL_CURSOR_SW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_W",SWIG_From_int(static_cast< int >(FL_CURSOR_W)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NW",SWIG_From_int(static_cast< int >(FL_CURSOR_NW)));
  SWIG_Python_SetConstant(d, "FL_CURSOR_NONE",SWIG_From_int(static_cast< int >(FL_CURSOR_NONE)));
  SWIG_Python_SetConstant(d, "FL_READ",SWIG_From_int(static_cast< int >(FL_READ)));
  SWIG_Python_SetConstant(d, "FL_WRITE",SWIG_From_int(static_cast< int >(FL_WRITE)));
  SWIG_Python_SetConstant(d, "FL_EXCEPT",SWIG_From_int(static_cast< int >(FL_EXCEPT)));
  SWIG_Python_SetConstant(d, "FL_RGB",SWIG_From_int(static_cast< int >(FL_RGB)));
  SWIG_Python_SetConstant(d, "FL_INDEX",SWIG_From_int(static_cast< int >(FL_INDEX)));
  SWIG_Python_SetConstant(d, "FL_SINGLE",SWIG_From_int(static_cast< int >(FL_SINGLE)));
  SWIG_Python_SetConstant(d, "FL_DOUBLE",SWIG_From_int(static_cast< int >(FL_DOUBLE)));
  SWIG_Python_SetConstant(d, "FL_ACCUM",SWIG_From_int(static_cast< int >(FL_ACCUM)));
  SWIG_Python_SetConstant(d, "FL_ALPHA",SWIG_From_int(static_cast< int >(FL_ALPHA)));
  SWIG_Python_SetConstant(d, "FL_DEPTH",SWIG_From_int(static_cast< int >(FL_DEPTH)));
  SWIG_Python_SetConstant(d, "FL_STENCIL",SWIG_From_int(static_cast< int >(FL_STENCIL)));
  SWIG_Python_SetConstant(d, "FL_RGB8",SWIG_From_int(static_cast< int >(FL_RGB8)));
  SWIG_Python_SetConstant(d, "FL_MULTISAMPLE",SWIG_From_int(static_cast< int >(FL_MULTISAMPLE)));
  SWIG_Python_SetConstant(d, "FL_STEREO",SWIG_From_int(static_cast< int >(FL_STEREO)));
  SWIG_Python_SetConstant(d, "FL_FAKE_SINGLE",SWIG_From_int(static_cast< int >(FL_FAKE_SINGLE)));
  SWIG_Python_SetConstant(d, "FL_OPENGL3",SWIG_From_int(static_cast< int >(FL_OPENGL3)));
  SWIG_Python_SetConstant(d, "FL_IMAGE_WITH_ALPHA",SWIG_From_int(static_cast< int >(0x40000000)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_CHILD",SWIG_From_int(static_cast< int >(FL_DAMAGE_CHILD)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_EXPOSE",SWIG_From_int(static_cast< int >(FL_DAMAGE_EXPOSE)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_SCROLL",SWIG_From_int(static_cast< int >(FL_DAMAGE_SCROLL)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_OVERLAY",SWIG_From_int(static_cast< int >(FL_DAMAGE_OVERLAY)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_USER1",SWIG_From_int(static_cast< int >(FL_DAMAGE_USER1)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_USER2",SWIG_From_int(static_cast< int >(FL_DAMAGE_USER2)));
  SWIG_Python_SetConstant(d, "FL_DAMAGE_ALL",SWIG_From_int(static_cast< int >(FL_DAMAGE_ALL)));
  SWIG_Python_SetConstant(d, "FL_RGB_SCALING_NEAREST",SWIG_From_int(static_cast< int >(FL_RGB_SCALING_NEAREST)));
  SWIG_Python_SetConstant(d, "FL_RGB_SCALING_BILINEAR",SWIG_From_int(static_cast< int >(FL_RGB_SCALING_BILINEAR)));
  SWIG_Python_SetConstant(d, "FL_RESERVED_TYPE",SWIG_From_int(static_cast< int >(100)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_BROWSER",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_SELECT_BROWSER",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_HOLD_BROWSER",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_MULTI_BROWSER",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_SORT_ASCENDING",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_SORT_DESCENDING",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "Fl_Browser__HORIZONTAL",SWIG_From_int(static_cast< int >(Fl_Browser_::HORIZONTAL)));
  SWIG_Python_SetConstant(d, "Fl_Browser__VERTICAL",SWIG_From_int(static_cast< int >(Fl_Browser_::VERTICAL)));
  SWIG_Python_SetConstant(d, "Fl_Browser__BOTH",SWIG_From_int(static_cast< int >(Fl_Browser_::BOTH)));
  SWIG_Python_SetConstant(d, "Fl_Browser__ALWAYS_ON",SWIG_From_int(static_cast< int >(Fl_Browser_::ALWAYS_ON)));
  SWIG_Python_SetConstant(d, "Fl_Browser__HORIZONTAL_ALWAYS",SWIG_From_int(static_cast< int >(Fl_Browser_::HORIZONTAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Browser__VERTICAL_ALWAYS",SWIG_From_int(static_cast< int >(Fl_Browser_::VERTICAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Browser__BOTH_ALWAYS",SWIG_From_int(static_cast< int >(Fl_Browser_::BOTH_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Browser_TOP",SWIG_From_int(static_cast< int >(Fl_Browser::TOP)));
  SWIG_Python_SetConstant(d, "Fl_Browser_BOTTOM",SWIG_From_int(static_cast< int >(Fl_Browser::BOTTOM)));
  SWIG_Python_SetConstant(d, "Fl_Browser_MIDDLE",SWIG_From_int(static_cast< int >(Fl_Browser::MIDDLE)));
  SWIG_Python_SetConstant(d, "Fl_File_Browser_FILES",SWIG_From_int(static_cast< int >(Fl_File_Browser::FILES)));
  SWIG_Python_SetConstant(d, "Fl_File_Browser_DIRECTORIES",SWIG_From_int(static_cast< int >(Fl_File_Browser::DIRECTORIES)));
  SWIG_Python_SetConstant(d, "FL_ALPHASORT",SWIG_From_int(static_cast< int >(FL_ALPHASORT)));
  SWIG_Python_SetConstant(d, "FL_CASEALPHASORT",SWIG_From_int(static_cast< int >(FL_CASEALPHASORT)));
  SWIG_Python_SetConstant(d, "FL_CASENUMERICSORT",SWIG_From_int(static_cast< int >(FL_CASENUMERICSORT)));
  SWIG_Python_SetConstant(d, "FL_NUMERICSORT",SWIG_From_int(static_cast< int >(FL_NUMERICSORT)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_ANY",SWIG_From_int(static_cast< int >(Fl_File_Icon::ANY)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_PLAIN",SWIG_From_int(static_cast< int >(Fl_File_Icon::PLAIN)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_FIFO",SWIG_From_int(static_cast< int >(Fl_File_Icon::FIFO)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_DEVICE",SWIG_From_int(static_cast< int >(Fl_File_Icon::DEVICE)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_LINK",SWIG_From_int(static_cast< int >(Fl_File_Icon::LINK)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_DIRECTORY",SWIG_From_int(static_cast< int >(Fl_File_Icon::DIRECTORY)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_END",SWIG_From_int(static_cast< int >(Fl_File_Icon::END)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_COLOR",SWIG_From_int(static_cast< int >(Fl_File_Icon::COLOR)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_LINE",SWIG_From_int(static_cast< int >(Fl_File_Icon::LINE)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_CLOSEDLINE",SWIG_From_int(static_cast< int >(Fl_File_Icon::CLOSEDLINE)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_POLYGON",SWIG_From_int(static_cast< int >(Fl_File_Icon::POLYGON)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_OUTLINEPOLYGON",SWIG_From_int(static_cast< int >(Fl_File_Icon::OUTLINEPOLYGON)));
  SWIG_Python_SetConstant(d, "Fl_File_Icon_VERTEX",SWIG_From_int(static_cast< int >(Fl_File_Icon::VERTEX)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_SINGLE",SWIG_From_int(static_cast< int >(Fl_File_Chooser::SINGLE)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_MULTI",SWIG_From_int(static_cast< int >(Fl_File_Chooser::MULTI)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_CREATE",SWIG_From_int(static_cast< int >(Fl_File_Chooser::CREATE)));
  SWIG_Python_SetConstant(d, "Fl_File_Chooser_DIRECTORY",SWIG_From_int(static_cast< int >(Fl_File_Chooser::DIRECTORY)));
  SWIG_Python_SetConstant(d, "Fl_OPTION_ARROW_FOCUS",SWIG_From_int(static_cast< int >(Fl::OPTION_ARROW_FOCUS)));
  SWIG_Python_SetConstant(d, "Fl_OPTION_VISIBLE_FOCUS",SWIG_From_int(static_cast< int >(Fl::OPTION_VISIBLE_FOCUS)));
  SWIG_Python_SetConstant(d, "Fl_OPTION_DND_TEXT",SWIG_From_int(static_cast< int >(Fl::OPTION_DND_TEXT)));
  SWIG_Python_SetConstant(d, "Fl_OPTION_SHOW_TOOLTIPS",SWIG_From_int(static_cast< int >(Fl::OPTION_SHOW_TOOLTIPS)));
  SWIG_Python_SetConstant(d, "Fl_OPTION_FNFC_USES_GTK",SWIG_From_int(static_cast< int >(Fl::OPTION_FNFC_USES_GTK)));
  SWIG_Python_SetConstant(d, "Fl_OPTION_LAST",SWIG_From_int(static_cast< int >(Fl::OPTION_LAST)));
  SWIG_Python_SetConstant(d, "FL_PATH_MAX",SWIG_From_int(static_cast< int >(2048)));
  SWIG_Python_SetConstant(d, "FL_BEEP_DEFAULT",SWIG_From_int(static_cast< int >(FL_BEEP_DEFAULT)));
  SWIG_Python_SetConstant(d, "FL_BEEP_MESSAGE",SWIG_From_int(static_cast< int >(FL_BEEP_MESSAGE)));
  SWIG_Python_SetConstant(d, "FL_BEEP_ERROR",SWIG_From_int(static_cast< int >(FL_BEEP_ERROR)));
  SWIG_Python_SetConstant(d, "FL_BEEP_QUESTION",SWIG_From_int(static_cast< int >(FL_BEEP_QUESTION)));
  SWIG_Python_SetConstant(d, "FL_BEEP_PASSWORD",SWIG_From_int(static_cast< int >(FL_BEEP_PASSWORD)));
  SWIG_Python_SetConstant(d, "FL_BEEP_NOTIFICATION",SWIG_From_int(static_cast< int >(FL_BEEP_NOTIFICATION)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_BUTTON",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_TOGGLE_BUTTON",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_RADIO_BUTTON",SWIG_From_int(static_cast< int >((100+2))));
  SWIG_Python_SetConstant(d, "FL_HIDDEN_BUTTON",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_BAR_CHART",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_HORBAR_CHART",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_LINE_CHART",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_FILL_CHART",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_SPIKE_CHART",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "FL_PIE_CHART",SWIG_From_int(static_cast< int >(5)));
  SWIG_Python_SetConstant(d, "FL_SPECIALPIE_CHART",SWIG_From_int(static_cast< int >(6)));
  SWIG_Python_SetConstant(d, "FL_FILLED_CHART",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_CHART_MAX",SWIG_From_int(static_cast< int >(128)));
  SWIG_Python_SetConstant(d, "FL_CHART_LABEL_MAX",SWIG_From_int(static_cast< int >(18)));
  SWIG_Python_SetConstant(d, "FL_SQUARE_CLOCK",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_ROUND_CLOCK",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_ANALOG_CLOCK",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_DIGITAL_CLOCK",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_COUNTER",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_SIMPLE_COUNTER",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_DIAL",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_LINE_DIAL",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_FILL_DIAL",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_WINDOW",SWIG_From_int(static_cast< int >(0xF0)));
  SWIG_Python_SetConstant(d, "FL_DOUBLE_WINDOW",SWIG_From_int(static_cast< int >(0xF1)));
  SWIG_Python_SetConstant(d, "FL_SOLID",SWIG_From_int(static_cast< int >(FL_SOLID)));
  SWIG_Python_SetConstant(d, "FL_DASH",SWIG_From_int(static_cast< int >(FL_DASH)));
  SWIG_Python_SetConstant(d, "FL_DOT",SWIG_From_int(static_cast< int >(FL_DOT)));
  SWIG_Python_SetConstant(d, "FL_DASHDOT",SWIG_From_int(static_cast< int >(FL_DASHDOT)));
  SWIG_Python_SetConstant(d, "FL_DASHDOTDOT",SWIG_From_int(static_cast< int >(FL_DASHDOTDOT)));
  SWIG_Python_SetConstant(d, "FL_CAP_FLAT",SWIG_From_int(static_cast< int >(FL_CAP_FLAT)));
  SWIG_Python_SetConstant(d, "FL_CAP_ROUND",SWIG_From_int(static_cast< int >(FL_CAP_ROUND)));
  SWIG_Python_SetConstant(d, "FL_CAP_SQUARE",SWIG_From_int(static_cast< int >(FL_CAP_SQUARE)));
  SWIG_Python_SetConstant(d, "FL_JOIN_MITER",SWIG_From_int(static_cast< int >(FL_JOIN_MITER)));
  SWIG_Python_SetConstant(d, "FL_JOIN_ROUND",SWIG_From_int(static_cast< int >(FL_JOIN_ROUND)));
  SWIG_Python_SetConstant(d, "FL_JOIN_BEVEL",SWIG_From_int(static_cast< int >(FL_JOIN_BEVEL)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_INPUT",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_FLOAT_INPUT",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_INT_INPUT",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_HIDDEN_INPUT",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_INPUT",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "FL_SECRET_INPUT",SWIG_From_int(static_cast< int >(5)));
  SWIG_Python_SetConstant(d, "FL_INPUT_TYPE",SWIG_From_int(static_cast< int >(7)));
  SWIG_Python_SetConstant(d, "FL_INPUT_READONLY",SWIG_From_int(static_cast< int >(8)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_OUTPUT",SWIG_From_int(static_cast< int >((0|8))));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_OUTPUT",SWIG_From_int(static_cast< int >((4|8))));
  SWIG_Python_SetConstant(d, "FL_INPUT_WRAP",SWIG_From_int(static_cast< int >(16)));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_INPUT_WRAP",SWIG_From_int(static_cast< int >((4|16))));
  SWIG_Python_SetConstant(d, "FL_MULTILINE_OUTPUT_WRAP",SWIG_From_int(static_cast< int >((4|8|16))));
  SWIG_Python_SetConstant(d, "FL_VERT_SLIDER",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_HOR_SLIDER",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_VERT_FILL_SLIDER",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_HOR_FILL_SLIDER",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_VERT_NICE_SLIDER",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "FL_HOR_NICE_SLIDER",SWIG_From_int(static_cast< int >(5)));
  SWIG_Python_SetConstant(d, "FL_NORMAL_FREE",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_SLEEPING_FREE",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_INPUT_FREE",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "FL_CONTINUOUS_FREE",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "FL_ALL_FREE",SWIG_From_int(static_cast< int >(5)));
  SWIG_Python_SetConstant(d, "FL_DRAW",SWIG_From_int(static_cast< int >(100)));
  SWIG_Python_SetConstant(d, "FL_STEP",SWIG_From_int(static_cast< int >(101)));
  SWIG_Python_SetConstant(d, "FL_FREEMEM",SWIG_From_int(static_cast< int >(102)));
  SWIG_Python_SetConstant(d, "FL_FREEZE",SWIG_From_int(static_cast< int >(103)));
  SWIG_Python_SetConstant(d, "FL_THAW",SWIG_From_int(static_cast< int >(104)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP1",SWIG_From_int(static_cast< int >(Fl_Menu_Button::POPUP1)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP2",SWIG_From_int(static_cast< int >(Fl_Menu_Button::POPUP2)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP12",SWIG_From_int(static_cast< int >(Fl_Menu_Button::POPUP12)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP3",SWIG_From_int(static_cast< int >(Fl_Menu_Button::POPUP3)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP13",SWIG_From_int(static_cast< int >(Fl_Menu_Button::POPUP13)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP23",SWIG_From_int(static_cast< int >(Fl_Menu_Button::POPUP23)));
  SWIG_Python_SetConstant(d, "Fl_Menu_Button_POPUP123",SWIG_From_int(static_cast< int >(Fl_Menu_Button::POPUP123)));
  SWIG_Python_SetConstant(d, "FL_MENU_INACTIVE",SWIG_From_int(static_cast< int >(FL_MENU_INACTIVE)));
  SWIG_Python_SetConstant(d, "FL_MENU_TOGGLE",SWIG_From_int(static_cast< int >(FL_MENU_TOGGLE)));
  SWIG_Python_SetConstant(d, "FL_MENU_VALUE",SWIG_From_int(static_cast< int >(FL_MENU_VALUE)));
  SWIG_Python_SetConstant(d, "FL_MENU_RADIO",SWIG_From_int(static_cast< int >(FL_MENU_RADIO)));
  SWIG_Python_SetConstant(d, "FL_MENU_INVISIBLE",SWIG_From_int(static_cast< int >(FL_MENU_INVISIBLE)));
  SWIG_Python_SetConstant(d, "FL_SUBMENU_POINTER",SWIG_From_int(static_cast< int >(FL_SUBMENU_POINTER)));
  SWIG_Python_SetConstant(d, "FL_SUBMENU",SWIG_From_int(static_cast< int >(FL_SUBMENU)));
  SWIG_Python_SetConstant(d, "FL_MENU_DIVIDER",SWIG_From_int(static_cast< int >(FL_MENU_DIVIDER)));
  SWIG_Python_SetConstant(d, "FL_MENU_HORIZONTAL",SWIG_From_int(static_cast< int >(FL_MENU_HORIZONTAL)));
  SWIG_Python_SetConstant(d, "FL_PUP_NONE",SWIG_From_int(static_cast< int >(FL_PUP_NONE)));
  SWIG_Python_SetConstant(d, "FL_PUP_GREY",SWIG_From_int(static_cast< int >(FL_PUP_GREY)));
  SWIG_Python_SetConstant(d, "FL_PUP_GRAY",SWIG_From_int(static_cast< int >(FL_PUP_GRAY)));
  SWIG_Python_SetConstant(d, "FL_MENU_BOX",SWIG_From_int(static_cast< int >(FL_MENU_BOX)));
  SWIG_Python_SetConstant(d, "FL_PUP_BOX",SWIG_From_int(static_cast< int >(FL_PUP_BOX)));
  SWIG_Python_SetConstant(d, "FL_MENU_CHECK",SWIG_From_int(static_cast< int >(FL_MENU_CHECK)));
  SWIG_Python_SetConstant(d, "FL_PUP_CHECK",SWIG_From_int(static_cast< int >(FL_PUP_CHECK)));
  SWIG_Python_SetConstant(d, "FL_PUP_RADIO",SWIG_From_int(static_cast< int >(FL_PUP_RADIO)));
  SWIG_Python_SetConstant(d, "FL_PUP_INVISIBLE",SWIG_From_int(static_cast< int >(FL_PUP_INVISIBLE)));
  SWIG_Python_SetConstant(d, "FL_PUP_SUBMENU",SWIG_From_int(static_cast< int >(FL_PUP_SUBMENU)));
  SWIG_Python_SetConstant(d, "Fl_Pack_VERTICAL",SWIG_From_int(static_cast< int >(Fl_Pack::VERTICAL)));
  SWIG_Python_SetConstant(d, "Fl_Pack_HORIZONTAL",SWIG_From_int(static_cast< int >(Fl_Pack::HORIZONTAL)));
  SWIG_Python_SetConstant(d, "Fl_Preferences_SYSTEM",SWIG_From_int(static_cast< int >(Fl_Preferences::SYSTEM)));
  SWIG_Python_SetConstant(d, "Fl_Preferences_USER",SWIG_From_int(static_cast< int >(Fl_Preferences::USER)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_HORIZONTAL",SWIG_From_int(static_cast< int >(Fl_Scroll::HORIZONTAL)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_VERTICAL",SWIG_From_int(static_cast< int >(Fl_Scroll::VERTICAL)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_BOTH",SWIG_From_int(static_cast< int >(Fl_Scroll::BOTH)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_ALWAYS_ON",SWIG_From_int(static_cast< int >(Fl_Scroll::ALWAYS_ON)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_HORIZONTAL_ALWAYS",SWIG_From_int(static_cast< int >(Fl_Scroll::HORIZONTAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_VERTICAL_ALWAYS",SWIG_From_int(static_cast< int >(Fl_Scroll::VERTICAL_ALWAYS)));
  SWIG_Python_SetConstant(d, "Fl_Scroll_BOTH_ALWAYS",SWIG_From_int(static_cast< int >(Fl_Scroll::BOTH_ALWAYS)));
  SWIG_Python_SetConstant(d, "FL_TEXT_MAX_EXP_CHAR_LEN",SWIG_From_int(static_cast< int >(20)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_NORMAL_CURSOR",SWIG_From_int(static_cast< int >(Fl_Text_Display::NORMAL_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_CARET_CURSOR",SWIG_From_int(static_cast< int >(Fl_Text_Display::CARET_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DIM_CURSOR",SWIG_From_int(static_cast< int >(Fl_Text_Display::DIM_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_BLOCK_CURSOR",SWIG_From_int(static_cast< int >(Fl_Text_Display::BLOCK_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_HEAVY_CURSOR",SWIG_From_int(static_cast< int >(Fl_Text_Display::HEAVY_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_SIMPLE_CURSOR",SWIG_From_int(static_cast< int >(Fl_Text_Display::SIMPLE_CURSOR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_CURSOR_POS",SWIG_From_int(static_cast< int >(Fl_Text_Display::CURSOR_POS)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_CHARACTER_POS",SWIG_From_int(static_cast< int >(Fl_Text_Display::CHARACTER_POS)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_NONE",SWIG_From_int(static_cast< int >(Fl_Text_Display::DRAG_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_START_DND",SWIG_From_int(static_cast< int >(Fl_Text_Display::DRAG_START_DND)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_CHAR",SWIG_From_int(static_cast< int >(Fl_Text_Display::DRAG_CHAR)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_WORD",SWIG_From_int(static_cast< int >(Fl_Text_Display::DRAG_WORD)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_DRAG_LINE",SWIG_From_int(static_cast< int >(Fl_Text_Display::DRAG_LINE)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_NONE",SWIG_From_int(static_cast< int >(Fl_Text_Display::WRAP_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_AT_COLUMN",SWIG_From_int(static_cast< int >(Fl_Text_Display::WRAP_AT_COLUMN)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_AT_PIXEL",SWIG_From_int(static_cast< int >(Fl_Text_Display::WRAP_AT_PIXEL)));
  SWIG_Python_SetConstant(d, "Fl_Text_Display_WRAP_AT_BOUNDS",SWIG_From_int(static_cast< int >(Fl_Text_Display::WRAP_AT_BOUNDS)));
  SWIG_Python_SetConstant(d, "FL_TEXT_EDITOR_ANY_STATE",SWIG_From_long(static_cast< long >((-1L))));
  SWIG_Python_SetConstant(d, "FL_NORMAL_TIMER",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "FL_VALUE_TIMER",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "FL_HIDDEN_TIMER",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "FL_TREE_SORT_NONE",SWIG_From_int(static_cast< int >(FL_TREE_SORT_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SORT_ASCENDING",SWIG_From_int(static_cast< int >(FL_TREE_SORT_ASCENDING)));
  SWIG_Python_SetConstant(d, "FL_TREE_SORT_DESCENDING",SWIG_From_int(static_cast< int >(FL_TREE_SORT_DESCENDING)));
  SWIG_Python_SetConstant(d, "FL_TREE_CONNECTOR_NONE",SWIG_From_int(static_cast< int >(FL_TREE_CONNECTOR_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_CONNECTOR_DOTTED",SWIG_From_int(static_cast< int >(FL_TREE_CONNECTOR_DOTTED)));
  SWIG_Python_SetConstant(d, "FL_TREE_CONNECTOR_SOLID",SWIG_From_int(static_cast< int >(FL_TREE_CONNECTOR_SOLID)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_NONE",SWIG_From_int(static_cast< int >(FL_TREE_SELECT_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_SINGLE",SWIG_From_int(static_cast< int >(FL_TREE_SELECT_SINGLE)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_MULTI",SWIG_From_int(static_cast< int >(FL_TREE_SELECT_MULTI)));
  SWIG_Python_SetConstant(d, "FL_TREE_SELECT_SINGLE_DRAGGABLE",SWIG_From_int(static_cast< int >(FL_TREE_SELECT_SINGLE_DRAGGABLE)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_NONE",SWIG_From_int(static_cast< int >(FL_TREE_REASON_NONE)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_SELECTED",SWIG_From_int(static_cast< int >(FL_TREE_REASON_SELECTED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_DESELECTED",SWIG_From_int(static_cast< int >(FL_TREE_REASON_DESELECTED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_OPENED",SWIG_From_int(static_cast< int >(FL_TREE_REASON_OPENED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_CLOSED",SWIG_From_int(static_cast< int >(FL_TREE_REASON_CLOSED)));
  SWIG_Python_SetConstant(d, "FL_TREE_REASON_DRAGGED",SWIG_From_int(static_cast< int >(FL_TREE_REASON_DRAGGED)));
  SWIG_Python_SetConstant(d, "NO_PAGE_FORMATS",SWIG_From_int(static_cast< int >(30)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A0",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A0)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A1",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A1)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A2",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A2)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A3",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A3)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A4",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A4)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A5",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A5)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A6",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A6)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A7",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A7)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A8",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A8)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_A9",SWIG_From_int(static_cast< int >(Fl_Paged_Device::A9)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B0",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B0)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B1",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B1)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B2",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B2)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B3",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B3)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B4",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B4)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B5",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B5)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B6",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B6)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B7",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B7)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B8",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B8)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B9",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B9)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_B10",SWIG_From_int(static_cast< int >(Fl_Paged_Device::B10)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_C5E",SWIG_From_int(static_cast< int >(Fl_Paged_Device::C5E)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_DLE",SWIG_From_int(static_cast< int >(Fl_Paged_Device::DLE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_EXECUTIVE",SWIG_From_int(static_cast< int >(Fl_Paged_Device::EXECUTIVE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_FOLIO",SWIG_From_int(static_cast< int >(Fl_Paged_Device::FOLIO)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LEDGER",SWIG_From_int(static_cast< int >(Fl_Paged_Device::LEDGER)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LEGAL",SWIG_From_int(static_cast< int >(Fl_Paged_Device::LEGAL)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LETTER",SWIG_From_int(static_cast< int >(Fl_Paged_Device::LETTER)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_TABLOID",SWIG_From_int(static_cast< int >(Fl_Paged_Device::TABLOID)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_ENVELOPE",SWIG_From_int(static_cast< int >(Fl_Paged_Device::ENVELOPE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_MEDIA",SWIG_From_int(static_cast< int >(Fl_Paged_Device::MEDIA)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_PORTRAIT",SWIG_From_int(static_cast< int >(Fl_Paged_Device::PORTRAIT)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_LANDSCAPE",SWIG_From_int(static_cast< int >(Fl_Paged_Device::LANDSCAPE)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_REVERSED",SWIG_From_int(static_cast< int >(Fl_Paged_Device::REVERSED)));
  SWIG_Python_SetConstant(d, "Fl_Paged_Device_ORIENTATION",SWIG_From_int(static_cast< int >(Fl_Paged_Device::ORIENTATION)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_NONE",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_STARTPAGE",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_STARTPAGE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_ENDPAGE",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_ENDPAGE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_ROW_HEADER",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_ROW_HEADER)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_COL_HEADER",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_COL_HEADER)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_CELL",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_CELL)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_TABLE",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_TABLE)));
  SWIG_Python_SetConstant(d, "Fl_Table_CONTEXT_RC_RESIZE",SWIG_From_int(static_cast< int >(Fl_Table::CONTEXT_RC_RESIZE)));
  SWIG_Python_SetConstant(d, "Fl_Table_Row_SELECT_NONE",SWIG_From_int(static_cast< int >(Fl_Table_Row::SELECT_NONE)));
  SWIG_Python_SetConstant(d, "Fl_Table_Row_SELECT_SINGLE",SWIG_From_int(static_cast< int >(Fl_Table_Row::SELECT_SINGLE)));
  SWIG_Python_SetConstant(d, "Fl_Table_Row_SELECT_MULTI",SWIG_From_int(static_cast< int >(Fl_Table_Row::SELECT_MULTI)));
  SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
  SWIG_Python_SetConstant(d, "M_PI_2",SWIG_From_double(static_cast< double >(1.57079632679489661923)));
  SWIG_Python_SetConstant(d, "M_PI_4",SWIG_From_double(static_cast< double >(0.78539816339744830962)));
  SWIG_Python_SetConstant(d, "M_1_PI",SWIG_From_double(static_cast< double >(0.31830988618379067154)));
  SWIG_Python_SetConstant(d, "M_2_PI",SWIG_From_double(static_cast< double >(0.63661977236758134308)));
  SWIG_Python_SetConstant(d, "M_SQRT2",SWIG_From_double(static_cast< double >(1.41421356237309504880)));
  SWIG_Python_SetConstant(d, "M_SQRT1_2",SWIG_From_double(static_cast< double >(0.70710678118654752440)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

