/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.21
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */


#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};                                                    
#endif

/* ruby.swg */
/* Implementation : RUBY */
#define SWIGRUBY 1

#include "ruby.h"

/* Flags for pointer conversion */
#define SWIG_POINTER_EXCEPTION     0x1
#define SWIG_POINTER_DISOWN        0x2

#define NUM2USHRT(n) (\
    (0 <= NUM2UINT(n) && NUM2UINT(n) <= USHRT_MAX)\
    ? (unsigned short) NUM2UINT(n) \
    : (rb_raise(rb_eArgError, "integer %d out of range of `unsigned short'",\
               NUM2UINT(n)), (short)0)\
)

#define NUM2SHRT(n) (\
    (SHRT_MIN <= NUM2INT(n) && NUM2INT(n) <= SHRT_MAX)\
    ? (short)NUM2INT(n)\
    : (rb_raise(rb_eArgError, "integer %d out of range of `short'",\
               NUM2INT(n)), (short)0)\
)

/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
#ifndef NUM2LL
#define NUM2LL(x) NUM2LONG((x))
#endif
#ifndef LL2NUM
#define LL2NUM(x) INT2NUM((long) (x))
#endif
#ifndef ULL2NUM
#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
#endif

/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
#ifndef NUM2ULL
#ifdef HAVE_LONG_LONG
#define NUM2ULL(x) rb_num2ull((x))
#else
#define NUM2ULL(x) NUM2ULONG(x)
#endif
#endif

/*
 * Need to be very careful about how these macros are defined, especially
 * when compiling C++ code or C code with an ANSI C compiler.
 *
 * VALUEFUNC(f) is a macro used to typecast a C function that implements
 * a Ruby method so that it can be passed as an argument to API functions
 * like rb_define_method() and rb_define_singleton_method().
 *
 * VOIDFUNC(f) is a macro used to typecast a C function that implements
 * either the "mark" or "free" stuff for a Ruby Data object, so that it
 * can be passed as an argument to API functions like Data_Wrap_Struct()
 * and Data_Make_Struct().
 */
 
#ifdef __cplusplus
#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
#    define VALUEFUNC(f) ((VALUE (*)()) f)
#    define VOIDFUNC(f)  ((void (*)()) f)
#  else
#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
#      define VALUEFUNC(f) ((VALUE (*)()) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    else /* These definitions should work for Ruby 1.7 */
#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    endif
#  endif
#else
#  define VALUEFUNC(f) (f)
#  define VOIDFUNC(f) (f)
#endif

typedef struct {
  VALUE klass;
  VALUE mImpl;
  void  (*mark)(void *);
  void  (*destroy)(void *);
} swig_class;

/* Don't use for expressions have side effect */
#ifndef RB_STRING_VALUE
#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
#endif
#ifndef StringValue
#define StringValue(s) RB_STRING_VALUE(s)
#endif
#ifndef StringValuePtr
#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr
#endif
#ifndef StringValueLen
#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len
#endif
#ifndef SafeStringValue
#define SafeStringValue(v) do {\
    StringValue(v);\
    rb_check_safe_str(v);\
} while (0)
#endif

#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
#endif

/* Contract support */

#define SWIG_contract_assert(expr, msg) if (!(expr)) { rb_raise(rb_eRuntimeError, (char *) msg ); } else


/*************************************************************** -*- c -*-
 * ruby/precommon.swg
 *
 * Rename all exported symbols from common.swg, to avoid symbol
 * clashes if multiple interpreters are included
 *
 ************************************************************************/

#define SWIG_TypeRegister    SWIG_Ruby_TypeRegister
#define SWIG_TypeCheck       SWIG_Ruby_TypeCheck
#define SWIG_TypeCast        SWIG_Ruby_TypeCast
#define SWIG_TypeDynamicCast SWIG_Ruby_TypeDynamicCast
#define SWIG_TypeName        SWIG_Ruby_TypeName
#define SWIG_TypeQuery       SWIG_Ruby_TypeQuery
#define SWIG_TypeClientData  SWIG_Ruby_TypeClientData
#define SWIG_PackData        SWIG_Ruby_PackData 
#define SWIG_UnpackData      SWIG_Ruby_UnpackData 

/* Also rename all exported symbols from rubydef.swig */

/* Common SWIG API */
#define SWIG_ConvertPtr(obj, pp, type, flags) \
  SWIG_Ruby_ConvertPtr(obj, pp, type, flags)
#define SWIG_NewPointerObj(p, type, flags) \
  SWIG_Ruby_NewPointerObj(p, type, flags)
#define SWIG_MustGetPtr(p, type, argnum, flags) \
  SWIG_Ruby_MustGetPtr(p, type, argnum, flags)

/* Ruby-specific SWIG API */

#define SWIG_InitRuntime() \
  SWIG_Ruby_InitRuntime()
#define SWIG_define_class(ty) \
  SWIG_Ruby_define_class(ty)
#define SWIG_NewClassInstance(value, ty) \
  SWIG_Ruby_NewClassInstance(value, ty)
#define SWIG_MangleStr(value) \
  SWIG_Ruby_MangleStr(value)
#define SWIG_CheckConvert(value, ty) \
  SWIG_Ruby_CheckConvert(value, ty)
#define SWIG_NewPackedObj(ptr, sz, ty) \
  SWIG_Ruby_NewPackedObj(ptr, sz, ty)
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \
  SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)


/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/

#include <string.h>

#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  if defined(_MSC_VER) || defined(__GNUC__)
#    if defined(STATIC_LINKED)
#      define SWIGEXPORT(a) a
#      define SWIGIMPORT(a) extern a
#    else
#      define SWIGEXPORT(a) __declspec(dllexport) a
#      define SWIGIMPORT(a) extern a
#    endif
#  else
#    if defined(__BORLANDC__)
#      define SWIGEXPORT(a) a _export
#      define SWIGIMPORT(a) a _export
#    else
#      define SWIGEXPORT(a) a
#      define SWIGIMPORT(a) a
#    endif
#  endif
#else
#  define SWIGEXPORT(a) a
#  define SWIGIMPORT(a) a
#endif

#ifdef SWIG_GLOBAL
#  define SWIGRUNTIME(a) SWIGEXPORT(a)
#else
#  define SWIGRUNTIME(a) static a
#endif

#ifdef __cplusplus
extern "C" {
#endif

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

typedef struct swig_type_info {
  const char             *name;
  swig_converter_func     converter;
  const char             *str;
  void                   *clientdata;
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
} swig_type_info;

#ifdef SWIG_NOINCLUDE

SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
SWIGIMPORT(char *)           SWIG_PackData(char *, void *, int);
SWIGIMPORT(char *)           SWIG_UnpackData(char *, void *, int);

#else

static swig_type_info *swig_type_list = 0;

/* Register a type mapping with the type-checking */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeRegister(swig_type_info *ti) {
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = swig_type_list;
  while (tc) {
    if (strcmp(tc->name, ti->name) == 0) {
      /* Already exists in the table.  Just add additional types to the list */
      if (tc->clientdata) ti->clientdata = tc->clientdata;
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = swig_type_list;
  swig_type_list = ti;

  /* Build linked lists */
  l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  if (next) next->prev = head;
  head->next = next;
  return ret;
}

/* Check the typename */
SWIGRUNTIME(swig_type_info *) 
SWIG_TypeCheck(char *c, swig_type_info *ty) {
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  do {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
        s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      s->prev = ty;
      return s;
    }
    s = s->next;
  } while (s && (s != ty->next));
  return 0;
}

/* Cast a pointer up an inheritance hierarchy */
SWIGRUNTIME(void *) 
SWIG_TypeCast(swig_type_info *ty, void *ptr) {
  if ((!ty) || (!ty->converter)) return ptr;
  return (*ty->converter)(ptr);
}

/* 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 */
SWIGRUNTIME(const char *)
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/* Search for a swig_type_info structure */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeQuery(const char *name) {
  swig_type_info *ty = swig_type_list;
  while (ty) {
    if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* Set the clientdata field for a type */
SWIGRUNTIME(void)
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata == clientdata) return;
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = swig_type_list;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0))
          SWIG_TypeClientData(tc,clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

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

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

#endif

#ifdef __cplusplus
}
#endif

/* rubydef.swg */
#ifdef __cplusplus
extern "C" {
#endif

static VALUE _mSWIG = Qnil;
static VALUE _cSWIG_Pointer = Qnil;

/* Initialize Ruby runtime support */
SWIGRUNTIME(void)
SWIG_Ruby_InitRuntime(void)
{
    if (_mSWIG == Qnil) {
        _mSWIG = rb_define_module("SWIG");
    }
}

/* Define Ruby class for C type */
SWIGRUNTIME(void)
SWIG_Ruby_define_class(swig_type_info *type)
{
    VALUE klass;
    char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    sprintf(klass_name, "TYPE%s", type->name);
    if (NIL_P(_cSWIG_Pointer)) {
	_cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
	rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
    }
    klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
    free((void *) klass_name);
}

/* Create a new pointer object */
SWIGRUNTIME(VALUE)
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int own)
{
    char *klass_name;
    swig_class *sklass;
    VALUE klass;
    VALUE obj;
    
    if (!ptr)
	return Qnil;
    
    if (type->clientdata) {
      sklass = (swig_class *) type->clientdata;
      obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
    } else {
      klass_name = (char *) malloc(4 + strlen(type->name) + 1);
      sprintf(klass_name, "TYPE%s", type->name);
      klass = rb_const_get(_mSWIG, rb_intern(klass_name));
      free((void *) klass_name);
      obj = Data_Wrap_Struct(klass, 0, 0, ptr);
    }
    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
    return obj;
}

/* Create a new class instance (always owned) */
SWIGRUNTIME(VALUE)
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
{
    VALUE obj;
    swig_class *sklass = (swig_class *) type->clientdata;
    obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
    return obj;
}

/* Get type mangle from class name */
SWIGRUNTIME(char *)
SWIG_Ruby_MangleStr(VALUE obj)
{
  VALUE stype = rb_iv_get(obj, "__swigtype__");
  return StringValuePtr(stype);
}

/* Convert a pointer value */
SWIGRUNTIME(int)
SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags)
{
  char *c;
  swig_type_info *tc;

  /* Grab the pointer */
  if (NIL_P(obj)) {
    *ptr = 0;
    return 0;
  } else {
    Data_Get_Struct(obj, void, *ptr);
  }
  
  /* Do type-checking if type info was provided */
  if (ty) {
    if (ty->clientdata) {
        if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
          if (*ptr == 0)
            rb_raise(rb_eRuntimeError, "This %s already released", ty->str);
          return 0;
        }
    }
    if ((c = SWIG_MangleStr(obj)) == NULL) {
      if (flags & SWIG_POINTER_EXCEPTION)
        rb_raise(rb_eTypeError, "Expected %s", ty->str);
      else
        return -1;
    }
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) {
      if (flags & SWIG_POINTER_EXCEPTION)
        rb_raise(rb_eTypeError, "Expected %s", ty->str);
      else
        return -1;
    }
    *ptr = SWIG_TypeCast(tc, *ptr);
  }
  return 0;
}

/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME(void *)
SWIG_Ruby_MustGetPtr(VALUE obj, swig_type_info *ty, int argnum, int flags)
{
  void *result;
  SWIG_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION);
  return result;
}

/* Check convert */
SWIGRUNTIME(int)
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
{
  char *c = SWIG_MangleStr(obj);
  if (!c)
    return 0;
  return SWIG_TypeCheck(c,ty) != 0;
}

SWIGRUNTIME(VALUE)
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r, ptr, sz);
  strcpy(r, type->name);
  return rb_str_new2(result);
}

/* Convert a packed value value */
SWIGRUNTIME(void)
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;

  if (TYPE(obj) != T_STRING) goto type_error;
  c = StringValuePtr(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c, ptr, sz);
  if (ty) {
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) goto type_error;
  }
  return;

type_error:

  if (flags) {
    if (ty) {
      rb_raise(rb_eTypeError, "Type error. Expected %s", ty->name);
    } else {
      rb_raise(rb_eTypeError, "Expected a pointer");
    }
  }
}

#ifdef __cplusplus
}
#endif



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

#define  SWIGTYPE_p_Icon swig_types[0] 
#define  SWIGTYPE_p_Tileset swig_types[1] 
#define  SWIGTYPE_p_CL_Color swig_types[2] 
#define  SWIGTYPE_p_CL_Size swig_types[3] 
#define  SWIGTYPE_p_Tile swig_types[4] 
#define  SWIGTYPE_p_ZoomTool swig_types[5] 
#define  SWIGTYPE_p_CL_Pointf swig_types[6] 
#define  SWIGTYPE_p_CL_MenuNode swig_types[7] 
#define  SWIGTYPE_p_CL_PixelBuffer swig_types[8] 
#define  SWIGTYPE_p_Tool swig_types[9] 
#define  SWIGTYPE_p_ObjMapSelectTool swig_types[10] 
#define  SWIGTYPE_p_TileMapSelectTool swig_types[11] 
#define  SWIGTYPE_p_CL_SlotContainer swig_types[12] 
#define  SWIGTYPE_p_CL_Button swig_types[13] 
#define  SWIGTYPE_p_Console swig_types[14] 
#define  SWIGTYPE_p_CL_Point swig_types[15] 
#define  SWIGTYPE_p_TileMapPaintTool swig_types[16] 
#define  SWIGTYPE_p_Minimap swig_types[17] 
#define  SWIGTYPE_p_CL_Rect swig_types[18] 
#define  SWIGTYPE_p_DirectoryView swig_types[19] 
#define  SWIGTYPE_p_CL_InputBox swig_types[20] 
#define  SWIGTYPE_p_TileBrush swig_types[21] 
#define  SWIGTYPE_p_ObjectBrush swig_types[22] 
#define  SWIGTYPE_p_CL_Label swig_types[23] 
#define  SWIGTYPE_p_Panel swig_types[24] 
#define  SWIGTYPE_p_int swig_types[25] 
#define  SWIGTYPE_p_CL_Signal_v1Tint_t swig_types[26] 
#define  SWIGTYPE_p_Scrollbar swig_types[27] 
#define  SWIGTYPE_p_ObjMapSpriteObject swig_types[28] 
#define  SWIGTYPE_p_CL_Sprite swig_types[29] 
#define  SWIGTYPE_p_Workspace swig_types[30] 
#define  SWIGTYPE_p_ObjectLayer swig_types[31] 
#define  SWIGTYPE_p_Window swig_types[32] 
#define  SWIGTYPE_p_CL_Window swig_types[33] 
#define  SWIGTYPE_p_EditorMapComponent swig_types[34] 
#define  SWIGTYPE_p_CL_Component swig_types[35] 
#define  SWIGTYPE_p_ObjMapPathNode swig_types[36] 
#define  SWIGTYPE_p_Layer swig_types[37] 
#define  SWIGTYPE_p_ObjMapSelectTool__Selection swig_types[38] 
#define  SWIGTYPE_p_CL_InputEvent swig_types[39] 
#define  SWIGTYPE_p_CL_ListBox swig_types[40] 
#define  SWIGTYPE_p_Menubar swig_types[41] 
#define  SWIGTYPE_p_TileSelector__Tiles swig_types[42] 
#define  SWIGTYPE_p_CL_Signal_v1Tstd__string_t swig_types[43] 
#define  SWIGTYPE_p_std__listTstd__string_t swig_types[44] 
#define  SWIGTYPE_p_CL_Signal_v1TCL_Menu_p_t swig_types[45] 
#define  SWIGTYPE_p_SharedPtrTMetaDataImpl_t swig_types[46] 
#define  SWIGTYPE_p_GraphicContextState swig_types[47] 
#define  SWIGTYPE_p_CL_Signal_v0 swig_types[48] 
#define  SWIGTYPE_p_Editor swig_types[49] 
#define  SWIGTYPE_p_CL_Signal_v1Tfloat_t swig_types[50] 
#define  SWIGTYPE_p_NetPanzerFileStruct swig_types[51] 
#define  SWIGTYPE_p_GUIManager swig_types[52] 
#define  SWIGTYPE_p_CL_StyleManager swig_types[53] 
#define  SWIGTYPE_p_CL_ResourceManager swig_types[54] 
#define  SWIGTYPE_p_CL_InputSourceProvider swig_types[55] 
#define  SWIGTYPE_p_std__vectorTint_t swig_types[56] 
#define  SWIGTYPE_p_FieldTint_t swig_types[57] 
#define  SWIGTYPE_p_ObjMapObject swig_types[58] 
#define  SWIGTYPE_p_Menu swig_types[59] 
#define  SWIGTYPE_p_Command swig_types[60] 
#define  SWIGTYPE_p_PaintCommand swig_types[61] 
#define  SWIGTYPE_p_ObjectMoveCommand swig_types[62] 
#define  SWIGTYPE_p_ObjectAddCommand swig_types[63] 
#define  SWIGTYPE_p_ObjectDeleteCommand swig_types[64] 
#define  SWIGTYPE_p_EditorMap swig_types[65] 
#define  SWIGTYPE_p_Flexlay swig_types[66] 
#define  SWIGTYPE_p_std__string swig_types[67] 
#define  SWIGTYPE_p_CL_Signal_v2Tint_int_t swig_types[68] 
#define  SWIGTYPE_p_CL_Menu swig_types[69] 
#define  SWIGTYPE_p_MetaData swig_types[70] 
#define  SWIGTYPE_p_CL_Signal_v1TObjMapObject_t swig_types[71] 
#define  SWIGTYPE_p_std__vectorTObjMapObject_t swig_types[72] 
#define  SWIGTYPE_p_TilemapLayer swig_types[73] 
#define  SWIGTYPE_p_ObjectSelector swig_types[74] 
#define  SWIGTYPE_p_TileSelector swig_types[75] 
#define  SWIGTYPE_p_SharedPtrTLayerImpl_t swig_types[76] 
#define  SWIGTYPE_p_SharedPtrTCommandImpl_t swig_types[77] 
#define  SWIGTYPE_p_SharedPtrTObjMapObjectImpl_t swig_types[78] 
static swig_type_info *swig_types[80];

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

#define SWIG_init    Init_flexlay_wrap
#define SWIG_name    "Flexlay_wrap"

static VALUE mFlexlay_wrap;

#include <ClanLib/Display/color.h>
#include <ClanLib/GUI/component.h>
#include <ClanLib/GUI/button.h>
#include <ClanLib/GUI/window.h>
#include <ClanLib/Core/Math/rect.h>
#include <ClanLib/Core/Math/point.h>
#include "command.hxx"
#include "paint_command.hxx"
#include "object_move_command.hxx"
#include "object_add_command.hxx"
#include "object_delete_command.hxx"
#include "tile.hxx"
#include "tile_brush.hxx"
#include "editor.hxx"
#include "meta_data.hxx"
#include "console.hxx"

#include "layer.hxx"
#include "tilemap_layer.hxx"
#include "object_layer.hxx"

#include "minimap.hxx"
#include "editor_map.hxx"
#include "workspace.hxx"
#include "tileset.hxx"
#include "editor_map_component.hxx"
#include "flexlay.hxx"
#include "globals.hxx"
#include "gui_manager.hxx"
#include "tile_selector.hxx"
#include "object_brush.hxx"
#include "object_selector.hxx"
#include "icon.hxx"
#include "window.hxx"
#include "panel.hxx"
#include "directory_view.hxx"
#include "menu.hxx"
#include "menubar.hxx"
#include "scrollbar.hxx"
#include "graphic_context_state.hxx"

#include "tilemap_paint_tool.hxx"
#include "tilemap_select_tool.hxx"
#include "objmap_select_tool.hxx"
#include "objmap_sprite_object.hxx"
#include "objmap_object.hxx"
#include "zoom_tool.hxx"
#include "objmap_path_node.hxx"

#include "netpanzer.hxx" 
#include "helper.hxx"

#ifdef SWIGPYTHON
#include "sexpr_parser.hxx"
#include "python_meta_data.hxx"
#include "python_functor.hxx"
#endif

#ifdef SWIGRUBY
#include "ruby_sexpr_parser.hxx"
#include "ruby_meta_data.hxx"
#include "ruby_functor.hxx"

VALUE ObjMapObject2Value(const ObjMapObject& arg)
{
 ObjMapObject* resultptr = new ObjMapObject(arg);
 return SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ObjMapObject, 1);
}

#endif


#define  SWIG_MemoryError    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_UnknownError  99


static void SWIG_exception_(int code, const char *msg) {
    switch (code) {
        case SWIG_MemoryError:
            rb_raise(rb_eNoMemError, msg);
            break;
        case SWIG_IOError:
            rb_raise(rb_eIOError, msg);
            break;
        case SWIG_RuntimeError:
            rb_raise(rb_eRuntimeError, msg);
            break;
        case SWIG_IndexError:
            rb_raise(rb_eIndexError, msg);
            break;
        case SWIG_TypeError:
            rb_raise(rb_eTypeError, msg);
            break;
        case SWIG_DivisionByZero:
            rb_raise(rb_eZeroDivError, msg);
            break;
        case SWIG_OverflowError:
            rb_raise(rb_eRangeError, msg);
            break;
        case SWIG_SyntaxError:
            rb_raise(rb_eSyntaxError, msg);
            break;
        case SWIG_ValueError:
            rb_raise(rb_eArgError, msg);
            break;
        case SWIG_SystemError:
            rb_raise(rb_eFatal, msg);
            break;
        case SWIG_UnknownError:
            rb_raise(rb_eRuntimeError, msg);
            break;
        default:
            break;
    }
}

#define SWIG_exception(a, b) SWIG_exception_((a), (b))


#include <string>


#include <string>

#define SWIG_FLOAT_P(x) ((TYPE(x) == T_FLOAT) || FIXNUM_P(x))

bool SWIG_BOOL_P(VALUE) {
    // dummy test, RTEST should take care of everything
    return true;
}
bool SWIG_RB2BOOL(VALUE x) {
    return RTEST(x);
}
VALUE SWIG_BOOL2RB(bool b) {
    return b ? Qtrue : Qfalse;
}
double SWIG_NUM2DBL(VALUE x) {
    return (FIXNUM_P(x) ? FIX2INT(x) : NUM2DBL(x));
}
bool SWIG_STRING_P(VALUE x) {
    return TYPE(x) == T_STRING;
}
std::string SWIG_RB2STR(VALUE x) {
    return std::string(StringValuePtr(x));
}
VALUE SWIG_STR2RB(const std::string& s) {
    return rb_str_new2(s.c_str());
}


#include <vector>
#include <algorithm>
#include <stdexcept>

int std_vectorlint_g_pop___(std::vector<int > *self){
                if (self->size() == 0)
                    throw std::out_of_range("pop from empty vector");
                int x = self->back();
                self->pop_back();
                return x;
            }
int std_vectorlint_g___getitem_____(std::vector<int > *self,int i){
                int size = int(self->size());
                if (i<0) i += size;
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
void std_vectorlint_g___setitem_____(std::vector<int > *self,int i,int x){
                int size = int(self->size());
                if (i<0) i+= size;
                if (i>=0 && i<size)
                    (*self)[i] = x;
                else
                    throw std::out_of_range("vector index out of range");
            }
void std_vectorlint_g_each___(std::vector<int > *self){
                for (unsigned int i=0; i<self->size(); i++)
                    rb_yield(INT2NUM((*self)[i]));
            }

swig_class cStd_vector_int;
static void free_std_vectorlint_g___(std::vector<int > *);
ObjMapObject std_vectorlObjMapObject_g_pop___(std::vector<ObjMapObject > *self){
                if (self->size() == 0)
                    throw std::out_of_range("pop from empty vector");
                ObjMapObject x = self->back();
                self->pop_back();
                return x;
            }
ObjMapObject &std_vectorlObjMapObject_g___getitem_____(std::vector<ObjMapObject > *self,int i){
                int size = int(self->size());
                if (i<0) i += size;
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
void std_vectorlObjMapObject_g___setitem_____(std::vector<ObjMapObject > *self,int i,ObjMapObject const &x){
                int size = int(self->size());
                if (i<0) i+= size;
                if (i>=0 && i<size)
                    (*self)[i] = x;
                else
                    throw std::out_of_range("vector index out of range");
            }
void std_vectorlObjMapObject_g_each___(std::vector<ObjMapObject > *self){
                for (unsigned int i=0; i<self->size(); i++) {
                    ObjMapObject* x = &((*self)[i]);
                    rb_yield(SWIG_NewPointerObj((void *) x, 
                                                SWIGTYPE_p_ObjMapObject, 0));
                }
            }

swig_class cStd_vector_ObjMapObject;
static void free_std_vectorlObjMapObject_g___(std::vector<ObjMapObject > *);

swig_class cCL_Component;

swig_class cCL_Size;
static void free_CL_Size(CL_Size *);

swig_class cCL_Point;
static void free_CL_Point(CL_Point *);

swig_class cCL_Rect;
static void free_CL_Rect(CL_Rect *);

swig_class cCL_Color;
static void free_CL_Color(CL_Color *);

swig_class cCL_Window;

swig_class cCL_Button;

swig_class cCL_Menu;

swig_class cCL_MenuNode;

swig_class cCL_InputBox;

swig_class cCL_Label;

swig_class cCL_ListBox;

swig_class cCL_ResourceManager;
static void free_CL_ResourceManager(CL_ResourceManager *);

swig_class cCommand;
static void free_Command(Command *);

swig_class cPaintCommand;
static void free_PaintCommand(PaintCommand *);

swig_class cObjectMoveCommand;
static void free_ObjectMoveCommand(ObjectMoveCommand *);

swig_class cObjectAddCommand;
static void free_ObjectAddCommand(ObjectAddCommand *);

swig_class cObjectDeleteCommand;
static void free_ObjectDeleteCommand(ObjectDeleteCommand *);

swig_class cTile;
static void free_Tile(Tile *);

swig_class cTileBrush;
static void free_TileBrush(TileBrush *);

swig_class cEditor;
static void free_Editor(Editor *);

swig_class cMetaData;
static void free_MetaData(MetaData *);

swig_class cConsole;
static void free_Console(Console *);

swig_class cLayer;
static void free_Layer(Layer *);

swig_class cTilemapLayer;
static void free_TilemapLayer(TilemapLayer *);

swig_class cObjectLayer;
static void free_ObjectLayer(ObjectLayer *);

swig_class cEditorMap;
static void free_EditorMap(EditorMap *);

swig_class cWorkspace;
static void free_Workspace(Workspace *);

swig_class cTileset;
static void free_Tileset(Tileset *);

swig_class cEditorMapComponent;
static void free_EditorMapComponent(EditorMapComponent *);

swig_class cFlexlay;
static void free_Flexlay(Flexlay *);
extern std::string datadir;
extern std::string bindir;
extern std::string homedir;
extern int debug;

swig_class cGUIManager;
static void free_GUIManager(GUIManager *);

swig_class cTileSelector;
static void free_TileSelector(TileSelector *);

swig_class cObjectBrush;
static void free_ObjectBrush(ObjectBrush *);

swig_class cObjectSelector;
static void free_ObjectSelector(ObjectSelector *);

swig_class cIcon;

swig_class cWindow;
static void free_Window(Window *);

swig_class cPanel;

swig_class cMinimap;

swig_class cDirectoryView;
static void free_DirectoryView(DirectoryView *);

swig_class cMenu;
static void free_Menu(Menu *);

swig_class cMenubar;

swig_class cScrollbar;

swig_class cTileMapPaintTool;
static void free_TileMapPaintTool(TileMapPaintTool *);

swig_class cTileMapSelectTool;
static void free_TileMapSelectTool(TileMapSelectTool *);

swig_class cObjMapSelectTool;
static void free_ObjMapSelectTool(ObjMapSelectTool *);

swig_class cObjMapSpriteObject;
static void free_ObjMapSpriteObject(ObjMapSpriteObject *);

swig_class cObjMapObject;
static void free_ObjMapObject(ObjMapObject *);

swig_class cZoomTool;
static void free_ZoomTool(ZoomTool *);

swig_class cGraphicContextState;
static void free_GraphicContextState(GraphicContextState *);

swig_class cObjMapPathNode;
static void free_ObjMapPathNode(ObjMapPathNode *);

swig_class cNetPanzerFileStruct;
static void free_NetPanzerFileStruct(NetPanzerFileStruct *);
static VALUE
_wrap_new_Std_vector_int__SWIG_0(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 = (unsigned int) 0 ;
    std::vector<int > *result;
    
    if ((argc < 0) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    if (argc > 0) {
        arg1 = NUM2UINT(argv[0]);
    }
    result = (std::vector<int > *)new std::vector<int >(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_Std_vector_int__SWIG_1(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 ;
    int *arg2 = 0 ;
    std::vector<int > *result;
    int temp2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2UINT(argv[0]);
    temp2 = (int) NUM2INT(argv[1]);
    arg2 = &temp2;
    result = (std::vector<int > *)new std::vector<int >(arg1,(int const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Std_vector_int_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Std_vector_int_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorTint_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Std_vector_int__SWIG_2(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = 0 ;
    std::vector<int > *result;
    std::vector<int > temp1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            temp1 = std::vector<int >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                if (FIXNUM_P(o))
                temp1[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
        }
    }
    result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Std_vector_int(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if ((argc >= 0) && (argc <= 1)) {
        int _v;
        if (argc <= 0) {
            return _wrap_new_Std_vector_int__SWIG_0(nargs, args, self);
        }
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Std_vector_int__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            /* native sequence? */
            if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
                unsigned int size = RARRAY(argv[0])->len;
                if (size == 0) {
                    /* an empty sequence can be of any type */
                    _v = 1;
                } else {
                    /* check the first element only */
                    VALUE o = RARRAY(argv[0])->ptr[0];
                    if (FIXNUM_P(o))
                    _v = 1;
                    else
                    _v = 0;
                }
            } else {
                /* wrapped vector? */
                std::vector<int >* v;
                if (SWIG_ConvertPtr(argv[0],(void **) &v, 
                SWIGTYPE_p_std__vectorTint_t,1) != -1)
                _v = 1;
                else
                _v = 0;
            }
        }
        if (_v) {
            return _wrap_new_Std_vector_int__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Std_vector_int__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Std_vector_int'");
    return Qnil;
}


static VALUE
_wrap_Std_vector_int___len__(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    unsigned int result;
    std::vector<int > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<int >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                if (FIXNUM_P(o))
                temp1[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
        }
    }
    result = (unsigned int)((std::vector<int > const *)arg1)->size();
    
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Std_vector_int_emptyq___(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    bool result;
    std::vector<int > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<int >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                if (FIXNUM_P(o))
                temp1[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
        }
    }
    result = (bool)((std::vector<int > const *)arg1)->empty();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Std_vector_int_clear(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    (arg1)->clear();
    
    return Qnil;
}


static VALUE
_wrap_Std_vector_int_push(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    arg2 = NUM2INT(argv[0]);
    (arg1)->push_back(arg2);
    
    return Qnil;
}


static VALUE
_wrap_Std_vector_int_pop(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    {
        try {
            result = (int)std_vectorlint_g_pop___(arg1);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Std_vector_int___getitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    arg2 = NUM2INT(argv[0]);
    {
        try {
            result = (int)std_vectorlint_g___getitem_____(arg1,arg2);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Std_vector_int___setitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    {
        try {
            std_vectorlint_g___setitem_____(arg1,arg2,arg3);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    return Qnil;
}


static VALUE
_wrap_Std_vector_int_each(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    std_vectorlint_g_each___(arg1);
    
    return Qnil;
}


static void
free_std_vectorlint_g___(std::vector<int > *arg1) {
    delete arg1;
}
static VALUE
_wrap_new_Std_vector_ObjMapObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 = (unsigned int) 0 ;
    std::vector<ObjMapObject > *result;
    
    if ((argc < 0) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    if (argc > 0) {
        arg1 = NUM2UINT(argv[0]);
    }
    result = (std::vector<ObjMapObject > *)new std::vector<ObjMapObject >(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_Std_vector_ObjMapObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 ;
    ObjMapObject *arg2 = 0 ;
    std::vector<ObjMapObject > *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2UINT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (std::vector<ObjMapObject > *)new std::vector<ObjMapObject >(arg1,(ObjMapObject const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Std_vector_ObjMapObject_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Std_vector_ObjMapObject_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorTObjMapObject_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Std_vector_ObjMapObject__SWIG_2(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = 0 ;
    std::vector<ObjMapObject > *result;
    std::vector<ObjMapObject > temp1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            temp1 = std::vector<ObjMapObject >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                ObjMapObject* x;
                SWIG_ConvertPtr(o, (void **) &x, SWIGTYPE_p_ObjMapObject, 1);
                temp1[i] = *x;
            }
        } else {
            SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
        }
    }
    result = (std::vector<ObjMapObject > *)new std::vector<ObjMapObject >((std::vector<ObjMapObject > const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Std_vector_ObjMapObject(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if ((argc >= 0) && (argc <= 1)) {
        int _v;
        if (argc <= 0) {
            return _wrap_new_Std_vector_ObjMapObject__SWIG_0(nargs, args, self);
        }
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Std_vector_ObjMapObject__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            /* native sequence? */
            if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
                unsigned int size = RARRAY(argv[0])->len;
                if (size == 0) {
                    /* an empty sequence can be of any type */
                    _v = 1;
                } else {
                    /* check the first element only */
                    ObjMapObject* x;
                    VALUE o = RARRAY(argv[0])->ptr[0];
                    if ((SWIG_ConvertPtr(o,(void **) &x, 
                    SWIGTYPE_p_ObjMapObject,0)) != -1)
                    _v = 1;
                    else
                    _v = 0;
                }
            } else {
                /* wrapped vector? */
                std::vector<ObjMapObject >* v;
                if (SWIG_ConvertPtr(argv[0],(void **) &v, 
                SWIGTYPE_p_std__vectorTObjMapObject_t,1) != -1)
                _v = 1;
                else
                _v = 0;
            }
        }
        if (_v) {
            return _wrap_new_Std_vector_ObjMapObject__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_ObjMapObject, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Std_vector_ObjMapObject__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Std_vector_ObjMapObject'");
    return Qnil;
}


static VALUE
_wrap_Std_vector_ObjMapObject___len__(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    unsigned int result;
    std::vector<ObjMapObject > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<ObjMapObject >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                ObjMapObject* x;
                SWIG_ConvertPtr(o, (void **) &x, SWIGTYPE_p_ObjMapObject, 1);
                temp1[i] = *x;
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
        }
    }
    result = (unsigned int)((std::vector<ObjMapObject > const *)arg1)->size();
    
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Std_vector_ObjMapObject_emptyq___(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    bool result;
    std::vector<ObjMapObject > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<ObjMapObject >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                ObjMapObject* x;
                SWIG_ConvertPtr(o, (void **) &x, SWIGTYPE_p_ObjMapObject, 1);
                temp1[i] = *x;
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
        }
    }
    result = (bool)((std::vector<ObjMapObject > const *)arg1)->empty();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Std_vector_ObjMapObject_clear(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
    (arg1)->clear();
    
    return Qnil;
}


static VALUE
_wrap_Std_vector_ObjMapObject_push(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    ObjMapObject *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->push_back((ObjMapObject const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Std_vector_ObjMapObject_pop(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    ObjMapObject result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
    {
        try {
            result = std_vectorlObjMapObject_g_pop___(arg1);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    {
        ObjMapObject * resultptr;
        resultptr = new ObjMapObject((ObjMapObject &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ObjMapObject, 1);
    }
    return vresult;
}


static VALUE
_wrap_Std_vector_ObjMapObject___getitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    int arg2 ;
    ObjMapObject *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
    arg2 = NUM2INT(argv[0]);
    {
        try {
            {
                ObjMapObject &_result_ref = std_vectorlObjMapObject_g___getitem_____(arg1,arg2);
                result = (ObjMapObject *) &_result_ref;
            }
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ObjMapObject,0);
    return vresult;
}


static VALUE
_wrap_Std_vector_ObjMapObject___setitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    int arg2 ;
    ObjMapObject *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_ObjMapObject, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    {
        try {
            std_vectorlObjMapObject_g___setitem_____(arg1,arg2,(ObjMapObject const &)*arg3);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    return Qnil;
}


static VALUE
_wrap_Std_vector_ObjMapObject_each(int argc, VALUE *argv, VALUE self) {
    std::vector<ObjMapObject > *arg1 = (std::vector<ObjMapObject > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTObjMapObject_t, 1);
    std_vectorlObjMapObject_g_each___(arg1);
    
    return Qnil;
}


static void
free_std_vectorlObjMapObject_g___(std::vector<ObjMapObject > *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Component_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Component_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Component);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Component(int argc, VALUE *argv, VALUE self) {
    CL_Component *arg1 = (CL_Component *) 0 ;
    CL_StyleManager *arg2 = (CL_StyleManager *) NULL ;
    CL_Component *result;
    
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Component, 1);
    if (argc > 1) {
        SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_StyleManager, 1);
    }
    result = (CL_Component *)new CL_Component(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_Component_show(int argc, VALUE *argv, VALUE self) {
    CL_Component *arg1 = (CL_Component *) 0 ;
    bool arg2 = (bool) true ;
    
    if ((argc < 0) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Component, 1);
    if (argc > 0) {
        arg2 = RTEST(argv[0]);
    }
    (arg1)->show(arg2);
    
    return Qnil;
}


static VALUE
_wrap_CL_Component_is_visible(int argc, VALUE *argv, VALUE self) {
    CL_Component *arg1 = (CL_Component *) 0 ;
    bool arg2 = (bool) true ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Component, 1);
    if (argc > 0) {
        arg2 = RTEST(argv[0]);
    }
    result = (bool)(arg1)->is_visible(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_CL_Component_set_size(int argc, VALUE *argv, VALUE self) {
    CL_Component *arg1 = (CL_Component *) 0 ;
    int arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Component, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    (arg1)->set_size(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_CL_Component_set_position(int argc, VALUE *argv, VALUE self) {
    CL_Component *arg1 = (CL_Component *) 0 ;
    int arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Component, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    (arg1)->set_position(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_CL_Component_get_position(int argc, VALUE *argv, VALUE self) {
    CL_Component *arg1 = (CL_Component *) 0 ;
    CL_Rect *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Component, 1);
    {
        CL_Rect const &_result_ref = (arg1)->get_position();
        result = (CL_Rect *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Rect,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Size_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Size_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Size);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Size(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    int arg2 ;
    CL_Size *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2INT(argv[0]);
    arg2 = NUM2INT(argv[1]);
    result = (CL_Size *)new CL_Size(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_Size_width_set(int argc, VALUE *argv, VALUE self) {
    CL_Size *arg1 = (CL_Size *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Size, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Size_width_get(int argc, VALUE *argv, VALUE self) {
    CL_Size *arg1 = (CL_Size *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Size, 1);
    result = (int) ((arg1)->width);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Size_height_set(int argc, VALUE *argv, VALUE self) {
    CL_Size *arg1 = (CL_Size *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Size, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Size_height_get(int argc, VALUE *argv, VALUE self) {
    CL_Size *arg1 = (CL_Size *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Size, 1);
    result = (int) ((arg1)->height);
    
    vresult = INT2NUM(result);
    return vresult;
}


static void
free_CL_Size(CL_Size *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Point_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Point_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Point);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Point(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    int arg2 ;
    CL_Point *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2INT(argv[0]);
    arg2 = NUM2INT(argv[1]);
    result = (CL_Point *)new CL_Point(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_Point_x_set(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = (CL_Point *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Point, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->x = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Point_x_get(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = (CL_Point *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Point, 1);
    result = (int) ((arg1)->x);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Point_y_set(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = (CL_Point *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Point, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->y = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Point_y_get(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = (CL_Point *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Point, 1);
    result = (int) ((arg1)->y);
    
    vresult = INT2NUM(result);
    return vresult;
}


static void
free_CL_Point(CL_Point *arg1) {
    delete arg1;
}
static VALUE
_wrap_CL_Rect_left_set(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->left = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Rect_left_get(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    result = (int) ((arg1)->left);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Rect_right_set(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->right = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Rect_right_get(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    result = (int) ((arg1)->right);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Rect_top_set(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->top = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Rect_top_get(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    result = (int) ((arg1)->top);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Rect_bottom_set(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->bottom = arg2;
    
    return Qnil;
}


static VALUE
_wrap_CL_Rect_bottom_get(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    result = (int) ((arg1)->bottom);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_new_CL_Rect__SWIG_0(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    CL_Rect *result;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    arg1 = NUM2INT(argv[0]);
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    arg4 = NUM2INT(argv[3]);
    result = (CL_Rect *)new CL_Rect(arg1,arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Rect_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Rect_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Rect);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Rect__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = 0 ;
    CL_Size *arg2 = 0 ;
    CL_Rect *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Point, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Size, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (CL_Rect *)new CL_Rect((CL_Point const &)*arg1,(CL_Size const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_CL_Rect(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_Point, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CL_Size, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_CL_Rect__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_new_CL_Rect__SWIG_0(nargs, args, self);
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_CL_Rect'");
    return Qnil;
}


static VALUE
_wrap_CL_Rect_get_width(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    result = (int)((CL_Rect const *)arg1)->get_width();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Rect_get_height(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    result = (int)((CL_Rect const *)arg1)->get_height();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Rect_get_size(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = (CL_Rect *) 0 ;
    SwigValueWrapper< CL_Size > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Rect, 1);
    result = (arg1)->get_size();
    
    {
        CL_Size * resultptr;
        resultptr = new CL_Size((CL_Size &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Size, 1);
    }
    return vresult;
}


static void
free_CL_Rect(CL_Rect *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Color_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Color_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Color);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Color(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 ;
    unsigned int arg2 ;
    unsigned int arg3 ;
    unsigned int arg4 = (unsigned int) 255 ;
    CL_Color *result;
    
    if ((argc < 3) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    arg1 = NUM2UINT(argv[0]);
    arg2 = NUM2UINT(argv[1]);
    arg3 = NUM2UINT(argv[2]);
    if (argc > 3) {
        arg4 = NUM2UINT(argv[3]);
    }
    result = (CL_Color *)new CL_Color(arg1,arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_Color_set_red(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    arg2 = NUM2UINT(argv[0]);
    (arg1)->set_red(arg2);
    
    return Qnil;
}


static VALUE
_wrap_CL_Color_set_blue(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    arg2 = NUM2UINT(argv[0]);
    (arg1)->set_blue(arg2);
    
    return Qnil;
}


static VALUE
_wrap_CL_Color_set_green(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    arg2 = NUM2UINT(argv[0]);
    (arg1)->set_green(arg2);
    
    return Qnil;
}


static VALUE
_wrap_CL_Color_set_alpha(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    arg2 = NUM2UINT(argv[0]);
    (arg1)->set_alpha(arg2);
    
    return Qnil;
}


static VALUE
_wrap_CL_Color_get_red(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    result = (unsigned int)(arg1)->get_red();
    
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Color_get_blue(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    result = (unsigned int)(arg1)->get_blue();
    
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Color_get_green(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    result = (unsigned int)(arg1)->get_green();
    
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CL_Color_get_alpha(int argc, VALUE *argv, VALUE self) {
    CL_Color *arg1 = (CL_Color *) 0 ;
    unsigned int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Color, 1);
    result = (unsigned int)(arg1)->get_alpha();
    
    vresult = UINT2NUM(result);
    return vresult;
}


static void
free_CL_Color(CL_Color *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Window_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Window_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Window);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Window(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    std::string *arg2 = 0 ;
    CL_Component *arg3 = (CL_Component *) 0 ;
    CL_StyleManager *arg4 = (CL_StyleManager *) NULL ;
    CL_Window *result;
    std::string temp2 ;
    
    if ((argc < 3) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[1]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_Component, 1);
    if (argc > 3) {
        SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_CL_StyleManager, 1);
    }
    result = (CL_Window *)new CL_Window((CL_Rect const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_Window_get_client_area(int argc, VALUE *argv, VALUE self) {
    CL_Window *arg1 = (CL_Window *) 0 ;
    CL_Component *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Window, 1);
    result = (CL_Component *)(arg1)->get_client_area();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Component,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Button_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Button_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Button);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Button(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    std::string *arg2 = 0 ;
    CL_Component *arg3 = (CL_Component *) 0 ;
    CL_StyleManager *arg4 = (CL_StyleManager *) NULL ;
    CL_Button *result;
    std::string temp2 ;
    
    if ((argc < 3) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[1]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_Component, 1);
    if (argc > 3) {
        SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_CL_StyleManager, 1);
    }
    result = (CL_Button *)new CL_Button((CL_Rect const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_Button_sig_clicked(int argc, VALUE *argv, VALUE self) {
    CL_Button *arg1 = (CL_Button *) 0 ;
    CL_Signal_v0 *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Button, 1);
    {
        CL_Signal_v0 &_result_ref = (arg1)->sig_clicked();
        result = (CL_Signal_v0 *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v0,0);
    return vresult;
}


static VALUE
_wrap_new_CL_Menu__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    CL_StyleManager *arg3 = (CL_StyleManager *) NULL ;
    bool arg4 = (bool) false ;
    CL_Menu *result;
    
    if ((argc < 2) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    if (argc > 2) {
        SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_StyleManager, 1);
    }
    if (argc > 3) {
        arg4 = RTEST(argv[3]);
    }
    result = (CL_Menu *)new CL_Menu((CL_Rect const &)*arg1,arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Menu_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Menu_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Menu);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Menu__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CL_Component *arg1 = (CL_Component *) 0 ;
    CL_StyleManager *arg2 = (CL_StyleManager *) NULL ;
    bool arg3 = (bool) false ;
    CL_Menu *result;
    
    if ((argc < 1) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Component, 1);
    if (argc > 1) {
        SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_StyleManager, 1);
    }
    if (argc > 2) {
        arg3 = RTEST(argv[2]);
    }
    result = (CL_Menu *)new CL_Menu(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_CL_Menu(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = args[ii];
    }
    if ((argc >= 1) && (argc <= 3)) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_Component, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            if (argc <= 1) {
                return _wrap_new_CL_Menu__SWIG_1(nargs, args, self);
            }
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CL_StyleManager, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                if (argc <= 2) {
                    return _wrap_new_CL_Menu__SWIG_1(nargs, args, self);
                }
                {
                    _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_CL_Menu__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if ((argc >= 2) && (argc <= 4)) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_Rect, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CL_Component, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                if (argc <= 2) {
                    return _wrap_new_CL_Menu__SWIG_0(nargs, args, self);
                }
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_CL_StyleManager, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    if (argc <= 3) {
                        return _wrap_new_CL_Menu__SWIG_0(nargs, args, self);
                    }
                    {
                        _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_new_CL_Menu__SWIG_0(nargs, args, self);
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_CL_Menu'");
    return Qnil;
}


static VALUE
_wrap_CL_Menu_create_item(int argc, VALUE *argv, VALUE self) {
    CL_Menu *arg1 = (CL_Menu *) 0 ;
    std::string *arg2 = 0 ;
    std::string const &arg3_defvalue = std::string() ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    CL_MenuNode *result;
    std::string temp2 ;
    std::string temp3 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_Menu, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    if (argc > 1) {
        {
            if (TYPE(argv[1]) == T_STRING) {
                temp3 = std::string(StringValuePtr(argv[1]));
                arg3 = &temp3;
            } else {
                SWIG_exception(SWIG_TypeError, "not a string");
            }
        }
    }
    result = (CL_MenuNode *)(arg1)->create_item((std::string const &)*arg2,(std::string const &)*arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_MenuNode,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_MenuNode_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_MenuNode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_MenuNode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_MenuNode(int argc, VALUE *argv, VALUE self) {
    CL_Menu *arg1 = (CL_Menu *) 0 ;
    CL_StyleManager *arg2 = (CL_StyleManager *) NULL ;
    CL_MenuNode *result;
    
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Menu, 1);
    if (argc > 1) {
        SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_StyleManager, 1);
    }
    result = (CL_MenuNode *)new CL_MenuNode(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_MenuNode_sig_clicked(int argc, VALUE *argv, VALUE self) {
    CL_MenuNode *arg1 = (CL_MenuNode *) 0 ;
    CL_Signal_v0 *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_MenuNode, 1);
    {
        CL_Signal_v0 &_result_ref = (arg1)->sig_clicked();
        result = (CL_Signal_v0 *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v0,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_InputBox_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_InputBox_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_InputBox);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_InputBox(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    CL_StyleManager *arg3 = (CL_StyleManager *) NULL ;
    CL_InputBox *result;
    
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    if (argc > 2) {
        SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_StyleManager, 1);
    }
    result = (CL_InputBox *)new CL_InputBox((CL_Rect const &)*arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_InputBox_set_text(int argc, VALUE *argv, VALUE self) {
    CL_InputBox *arg1 = (CL_InputBox *) 0 ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_InputBox, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    (arg1)->set_text((std::string const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_CL_InputBox_get_text(int argc, VALUE *argv, VALUE self) {
    CL_InputBox *arg1 = (CL_InputBox *) 0 ;
    std::string *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_InputBox, 1);
    {
        std::string const &_result_ref = ((CL_InputBox const *)arg1)->get_text();
        result = (std::string *) &_result_ref;
    }
    
    {
        vresult = rb_str_new2(result->c_str());
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_Label_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_Label_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_Label);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_Label(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = 0 ;
    std::string *arg2 = 0 ;
    CL_Component *arg3 = (CL_Component *) 0 ;
    CL_StyleManager *arg4 = (CL_StyleManager *) NULL ;
    CL_Label *result;
    std::string temp2 ;
    
    if ((argc < 3) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Point, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[1]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_Component, 1);
    if (argc > 3) {
        SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_CL_StyleManager, 1);
    }
    result = (CL_Label *)new CL_Label((CL_Point const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_ListBox_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_ListBox_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_ListBox);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_ListBox(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    CL_StyleManager *arg3 = (CL_StyleManager *) NULL ;
    CL_ListBox *result;
    
    if ((argc < 2) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    if (argc > 2) {
        SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_StyleManager, 1);
    }
    result = (CL_ListBox *)new CL_ListBox((CL_Rect const &)*arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_CL_ListBox_sig_highlighted(int argc, VALUE *argv, VALUE self) {
    CL_ListBox *arg1 = (CL_ListBox *) 0 ;
    CL_Signal_v1<int > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ListBox, 1);
    {
        CL_Signal_v1<int > &_result_ref = (arg1)->sig_highlighted();
        result = (CL_Signal_v1<int > *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v1Tint_t,0);
    return vresult;
}


static VALUE
_wrap_CL_ListBox_insert_item(int argc, VALUE *argv, VALUE self) {
    CL_ListBox *arg1 = (CL_ListBox *) 0 ;
    std::string *arg2 = 0 ;
    int arg3 = (int) -1 ;
    int result;
    std::string temp2 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ListBox, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    if (argc > 1) {
        arg3 = NUM2INT(argv[1]);
    }
    result = (int)(arg1)->insert_item((std::string const &)*arg2,arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_CL_ResourceManager_allocate(VALUE self) {
#else
    static VALUE
    _wrap_CL_ResourceManager_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CL_ResourceManager);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_CL_ResourceManager(int argc, VALUE *argv, VALUE self) {
    std::string *arg1 = 0 ;
    CL_InputSourceProvider *arg2 = (CL_InputSourceProvider *) 0 ;
    bool arg3 = (bool) false ;
    CL_ResourceManager *result;
    std::string temp1 ;
    
    if ((argc < 1) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp1 = std::string(StringValuePtr(argv[0]));
            arg1 = &temp1;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    if (argc > 1) {
        SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_InputSourceProvider, 1);
    }
    if (argc > 2) {
        arg3 = RTEST(argv[2]);
    }
    result = (CL_ResourceManager *)new CL_ResourceManager((std::string const &)*arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static void
free_CL_ResourceManager(CL_ResourceManager *arg1) {
    delete arg1;
}
static VALUE
_wrap_CL_ResourceManager_get_all_resources(int argc, VALUE *argv, VALUE self) {
    CL_ResourceManager *arg1 = (CL_ResourceManager *) 0 ;
    std::string *arg2 = 0 ;
    SwigValueWrapper< std::list<std::string > > result;
    std::string temp2 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ResourceManager, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    result = (arg1)->get_all_resources((std::string const &)*arg2);
    
    {
        std::list<std::string > * resultptr;
        resultptr = new std::list<std::string >((std::list<std::string > &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__listTstd__string_t, 1);
    }
    return vresult;
}


static VALUE
_wrap_CL_ResourceManager_get_all_sections(int argc, VALUE *argv, VALUE self) {
    CL_ResourceManager *arg1 = (CL_ResourceManager *) 0 ;
    SwigValueWrapper< std::list<std::string > > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ResourceManager, 1);
    result = (arg1)->get_all_sections();
    
    {
        std::list<std::string > * resultptr;
        resultptr = new std::list<std::string >((std::list<std::string > &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__listTstd__string_t, 1);
    }
    return vresult;
}


static VALUE
_wrap_CL_ResourceManager_get_resources_of_type__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CL_ResourceManager *arg1 = (CL_ResourceManager *) 0 ;
    std::string *arg2 = 0 ;
    SwigValueWrapper< std::list<std::string > > result;
    std::string temp2 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ResourceManager, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    result = (arg1)->get_resources_of_type((std::string const &)*arg2);
    
    {
        std::list<std::string > * resultptr;
        resultptr = new std::list<std::string >((std::list<std::string > &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__listTstd__string_t, 1);
    }
    return vresult;
}


static VALUE
_wrap_CL_ResourceManager_get_resources_of_type__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CL_ResourceManager *arg1 = (CL_ResourceManager *) 0 ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    SwigValueWrapper< std::list<std::string > > result;
    std::string temp2 ;
    std::string temp3 ;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ResourceManager, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp3 = std::string(StringValuePtr(argv[1]));
            arg3 = &temp3;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    result = (arg1)->get_resources_of_type((std::string const &)*arg2,(std::string const &)*arg3);
    
    {
        std::list<std::string > * resultptr;
        resultptr = new std::list<std::string >((std::list<std::string > &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__listTstd__string_t, 1);
    }
    return vresult;
}


static VALUE _wrap_CL_ResourceManager_get_resources_of_type(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_ResourceManager, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = (TYPE(argv[1]) == T_STRING) ? 1 : 0;
            }
            if (_v) {
                return _wrap_CL_ResourceManager_get_resources_of_type__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_ResourceManager, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = (TYPE(argv[1]) == T_STRING) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = (TYPE(argv[2]) == T_STRING) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_CL_ResourceManager_get_resources_of_type__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'CL_ResourceManager_get_resources_of_type'");
    return Qnil;
}


static VALUE
_wrap_CL_ResourceManager_add_resources(int argc, VALUE *argv, VALUE self) {
    CL_ResourceManager *arg1 = (CL_ResourceManager *) 0 ;
    CL_ResourceManager *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ResourceManager, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_ResourceManager, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_resources((CL_ResourceManager const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_CL_ResourceManager_remove_resources(int argc, VALUE *argv, VALUE self) {
    CL_ResourceManager *arg1 = (CL_ResourceManager *) 0 ;
    CL_ResourceManager *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CL_ResourceManager, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_ResourceManager, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->remove_resources((CL_ResourceManager const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_new_Command__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Command *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Command *)new Command();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Command_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Command_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Command);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Command__SWIG_1(int argc, VALUE *argv, VALUE self) {
    SharedPtr<CommandImpl > *arg1 = 0 ;
    Command *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_SharedPtrTCommandImpl_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Command *)new Command((SharedPtr<CommandImpl > const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Command(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Command__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_SharedPtrTCommandImpl_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Command__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Command'");
    return Qnil;
}


static VALUE
_wrap_Command_execute(int argc, VALUE *argv, VALUE self) {
    Command *arg1 = (Command *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Command, 1);
    (arg1)->execute();
    
    return Qnil;
}


static VALUE
_wrap_Command_redo(int argc, VALUE *argv, VALUE self) {
    Command *arg1 = (Command *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Command, 1);
    (arg1)->redo();
    
    return Qnil;
}


static VALUE
_wrap_Command_undo(int argc, VALUE *argv, VALUE self) {
    Command *arg1 = (Command *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Command, 1);
    (arg1)->undo();
    
    return Qnil;
}


static VALUE
_wrap_Command_serialize(int argc, VALUE *argv, VALUE self) {
    Command *arg1 = (Command *) 0 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Command, 1);
    result = (arg1)->serialize();
    
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static void
free_Command(Command *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_PaintCommand_allocate(VALUE self) {
#else
    static VALUE
    _wrap_PaintCommand_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_PaintCommand);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_PaintCommand(int argc, VALUE *argv, VALUE self) {
    TilemapLayer arg1 ;
    TileBrush *arg2 = 0 ;
    PaintCommand *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        TilemapLayer * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_TilemapLayer, 1);
        if (ptr) arg1 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_TileBrush, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (PaintCommand *)new PaintCommand(arg1,(TileBrush const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


static void
free_PaintCommand(PaintCommand *arg1) {
    delete arg1;
}
static VALUE
_wrap_PaintCommand_add_point(int argc, VALUE *argv, VALUE self) {
    PaintCommand *arg1 = (PaintCommand *) 0 ;
    CL_Point *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PaintCommand, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_point((CL_Point const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_PaintCommand_to_command(int argc, VALUE *argv, VALUE self) {
    PaintCommand *arg1 = (PaintCommand *) 0 ;
    Command result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PaintCommand, 1);
    result = (arg1)->to_command();
    
    {
        Command * resultptr;
        resultptr = new Command((Command &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Command, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjectMoveCommand_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjectMoveCommand_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjectMoveCommand);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjectMoveCommand(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = 0 ;
    ObjectMoveCommand *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjectMoveCommand *)new ObjectMoveCommand((ObjectLayer const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static void
free_ObjectMoveCommand(ObjectMoveCommand *arg1) {
    delete arg1;
}
static VALUE
_wrap_ObjectMoveCommand_add_obj(int argc, VALUE *argv, VALUE self) {
    ObjectMoveCommand *arg1 = (ObjectMoveCommand *) 0 ;
    ObjMapObject *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectMoveCommand, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_obj((ObjMapObject const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjectMoveCommand_move_by(int argc, VALUE *argv, VALUE self) {
    ObjectMoveCommand *arg1 = (ObjectMoveCommand *) 0 ;
    CL_Point *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectMoveCommand, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->move_by((CL_Point const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjectMoveCommand_to_command(int argc, VALUE *argv, VALUE self) {
    ObjectMoveCommand *arg1 = (ObjectMoveCommand *) 0 ;
    Command result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectMoveCommand, 1);
    result = (arg1)->to_command();
    
    {
        Command * resultptr;
        resultptr = new Command((Command &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Command, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjectAddCommand_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjectAddCommand_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjectAddCommand);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjectAddCommand(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = 0 ;
    ObjectAddCommand *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjectAddCommand *)new ObjectAddCommand((ObjectLayer const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static void
free_ObjectAddCommand(ObjectAddCommand *arg1) {
    delete arg1;
}
static VALUE
_wrap_ObjectAddCommand_add_object(int argc, VALUE *argv, VALUE self) {
    ObjectAddCommand *arg1 = (ObjectAddCommand *) 0 ;
    ObjMapObject *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectAddCommand, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_object((ObjMapObject const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjectAddCommand_to_command(int argc, VALUE *argv, VALUE self) {
    ObjectAddCommand *arg1 = (ObjectAddCommand *) 0 ;
    Command result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectAddCommand, 1);
    result = (arg1)->to_command();
    
    {
        Command * resultptr;
        resultptr = new Command((Command &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Command, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjectDeleteCommand_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjectDeleteCommand_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjectDeleteCommand);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjectDeleteCommand(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = 0 ;
    ObjectDeleteCommand *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjectDeleteCommand *)new ObjectDeleteCommand((ObjectLayer const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_ObjectDeleteCommand_add_object(int argc, VALUE *argv, VALUE self) {
    ObjectDeleteCommand *arg1 = (ObjectDeleteCommand *) 0 ;
    ObjMapObject *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectDeleteCommand, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_object((ObjMapObject const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjectDeleteCommand_to_command(int argc, VALUE *argv, VALUE self) {
    ObjectDeleteCommand *arg1 = (ObjectDeleteCommand *) 0 ;
    Command result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectDeleteCommand, 1);
    result = (arg1)->to_command();
    
    {
        Command * resultptr;
        resultptr = new Command((Command &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Command, 1);
    }
    return vresult;
}


static void
free_ObjectDeleteCommand(ObjectDeleteCommand *arg1) {
    delete arg1;
}
static VALUE
_wrap_new_Tile__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CL_PixelBuffer *arg1 = 0 ;
    Tile *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_PixelBuffer, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Tile *)new Tile((CL_PixelBuffer const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_Tile__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CL_PixelBuffer *arg1 = 0 ;
    CL_Sprite *arg2 = 0 ;
    Tile *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_PixelBuffer, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Sprite, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Tile *)new Tile((CL_PixelBuffer const &)*arg1,(CL_Sprite const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Tile_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Tile_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Tile);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Tile__SWIG_2(int argc, VALUE *argv, VALUE self) {
    std::string *arg1 = 0 ;
    CL_Color *arg2 = 0 ;
    Tile *result;
    std::string temp1 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp1 = std::string(StringValuePtr(argv[0]));
            arg1 = &temp1;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Tile *)new Tile((std::string const &)*arg1,(CL_Color const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Tile(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_PixelBuffer, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Tile__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_PixelBuffer, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CL_Sprite, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Tile__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = (TYPE(argv[0]) == T_STRING) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CL_Color, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Tile__SWIG_2(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Tile'");
    return Qnil;
}


static void
free_Tile(Tile *arg1) {
    delete arg1;
}
static VALUE
_wrap_Tile_get_sprite(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    CL_Sprite *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    {
        CL_Sprite &_result_ref = (arg1)->get_sprite();
        result = (CL_Sprite *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Sprite,0);
    return vresult;
}


static VALUE
_wrap_Tile_get_pixelbuffer(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    CL_PixelBuffer result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    result = (arg1)->get_pixelbuffer();
    
    {
        CL_PixelBuffer * resultptr;
        resultptr = new CL_PixelBuffer((CL_PixelBuffer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_PixelBuffer, 1);
    }
    return vresult;
}


static VALUE
_wrap_Tile_get_color(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    SwigValueWrapper< CL_Color > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    result = (arg1)->get_color();
    
    {
        CL_Color * resultptr;
        resultptr = new CL_Color((CL_Color &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Color, 1);
    }
    return vresult;
}


static VALUE
_wrap_Tile_get_attribute_color(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    SwigValueWrapper< CL_Color > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    result = (arg1)->get_attribute_color();
    
    {
        CL_Color * resultptr;
        resultptr = new CL_Color((CL_Color &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Color, 1);
    }
    return vresult;
}


static VALUE
_wrap_Tile_get_filename(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    result = ((Tile const *)arg1)->get_filename();
    
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_Tile_get_col(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    unsigned char arg2 ;
    unsigned char arg3 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    arg2 = (unsigned char) NUM2INT(argv[0]);
    arg3 = (unsigned char) NUM2INT(argv[1]);
    result = (bool)(arg1)->get_col(arg2,arg3);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Tile_set_col(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    unsigned char arg2 ;
    unsigned char arg3 ;
    bool arg4 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    arg2 = (unsigned char) NUM2INT(argv[0]);
    arg3 = (unsigned char) NUM2INT(argv[1]);
    arg4 = RTEST(argv[2]);
    (arg1)->set_col(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_Tile_calc_color(int argc, VALUE *argv, VALUE self) {
    Tile *arg1 = (Tile *) 0 ;
    SwigValueWrapper< CL_Color > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tile, 1);
    result = (arg1)->calc_color();
    
    {
        CL_Color * resultptr;
        resultptr = new CL_Color((CL_Color &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Color, 1);
    }
    return vresult;
}


static VALUE
_wrap_new_TileBrush__SWIG_0(int argc, VALUE *argv, VALUE self) {
    TileBrush *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (TileBrush *)new TileBrush();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_TileBrush__SWIG_1(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    int arg2 ;
    TileBrush *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2INT(argv[0]);
    arg2 = NUM2INT(argv[1]);
    result = (TileBrush *)new TileBrush(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_TileBrush_allocate(VALUE self) {
#else
    static VALUE
    _wrap_TileBrush_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TileBrush);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_TileBrush__SWIG_2(int argc, VALUE *argv, VALUE self) {
    Field<int > *arg1 = 0 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    TileBrush *result;
    
    if ((argc < 5) || (argc > 5))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FieldTint_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    arg4 = NUM2INT(argv[3]);
    arg5 = NUM2INT(argv[4]);
    result = (TileBrush *)new TileBrush((Field<int > const &)*arg1,arg2,arg3,arg4,arg5);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_TileBrush(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[5];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 5); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_TileBrush__SWIG_0(nargs, args, self);
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_TileBrush__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_FieldTint_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            _v = ((TYPE(argv[4]) == T_FIXNUM) || (TYPE(argv[4]) == T_BIGNUM)) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_new_TileBrush__SWIG_2(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_TileBrush'");
    return Qnil;
}


static VALUE
_wrap_TileBrush_get_width(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    result = (int)((TileBrush const *)arg1)->get_width();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_TileBrush_get_height(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    result = (int)((TileBrush const *)arg1)->get_height();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_TileBrush_set_data(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    std::vector<int > *arg2 = 0 ;
    std::vector<int > temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            temp2 = std::vector<int >(size);
            arg2 = &temp2;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                if (FIXNUM_P(o))
                temp2[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_std__vectorTint_t, 1);
        }
    }
    (arg1)->set_data((std::vector<int > const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_TileBrush_get_data(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    std::vector<int > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    result = (arg1)->get_data();
    
    {
        vresult = rb_ary_new2((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        rb_ary_store(vresult,i,INT2NUM(((std::vector<int > &)result)[i]));
    }
    return vresult;
}


static VALUE
_wrap_TileBrush_at__SWIG_0(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    int arg2 ;
    int arg3 ;
    int *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    {
        int const &_result_ref = ((TileBrush const *)arg1)->at(arg2,arg3);
        result = (int *) &_result_ref;
    }
    
    vresult = INT2NUM((long) *(result));
    return vresult;
}


static VALUE
_wrap_TileBrush_at__SWIG_1(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    int arg2 ;
    int arg3 ;
    int *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    {
        int &_result_ref = (arg1)->at(arg2,arg3);
        result = (int *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_int,0);
    return vresult;
}


static VALUE _wrap_TileBrush_at(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_TileBrush, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_TileBrush_at__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_TileBrush, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_TileBrush_at__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'TileBrush_at'");
    return Qnil;
}


static VALUE
_wrap_TileBrush_resize(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    int arg2 ;
    int arg3 ;
    int arg4 = (int) 0 ;
    int arg5 = (int) 0 ;
    
    if ((argc < 2) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    if (argc > 2) {
        arg4 = NUM2INT(argv[2]);
    }
    if (argc > 3) {
        arg5 = NUM2INT(argv[3]);
    }
    (arg1)->resize(arg2,arg3,arg4,arg5);
    
    return Qnil;
}


static VALUE
_wrap_TileBrush_set_opaque(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    (arg1)->set_opaque();
    
    return Qnil;
}


static VALUE
_wrap_TileBrush_set_transparent(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    (arg1)->set_transparent();
    
    return Qnil;
}


static VALUE
_wrap_TileBrush_is_opaque(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    result = (bool)((TileBrush const *)arg1)->is_opaque();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_TileBrush_auto_crop(int argc, VALUE *argv, VALUE self) {
    TileBrush *arg1 = (TileBrush *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileBrush, 1);
    (arg1)->auto_crop();
    
    return Qnil;
}


static void
free_TileBrush(TileBrush *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Editor_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Editor_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Editor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Editor(int argc, VALUE *argv, VALUE self) {
    Editor *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Editor *)new Editor();
    DATA_PTR(self) = result;
    return self;
}


static void
free_Editor(Editor *arg1) {
    delete arg1;
}
static VALUE
_wrap_Editor_get_gui_manager(int argc, VALUE *argv, VALUE self) {
    Editor *arg1 = (Editor *) 0 ;
    GUIManager *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Editor, 1);
    result = (GUIManager *)((Editor const *)arg1)->get_gui_manager();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_GUIManager,0);
    return vresult;
}


static VALUE
_wrap_Editor_run(int argc, VALUE *argv, VALUE self) {
    Editor *arg1 = (Editor *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Editor, 1);
    (arg1)->run();
    
    return Qnil;
}


static VALUE
_wrap_new_MetaData__SWIG_0(int argc, VALUE *argv, VALUE self) {
    MetaData *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (MetaData *)new MetaData();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_MetaData_allocate(VALUE self) {
#else
    static VALUE
    _wrap_MetaData_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_MetaData);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_MetaData__SWIG_1(int argc, VALUE *argv, VALUE self) {
    SwigValueWrapper< SharedPtr<MetaDataImpl > > arg1 ;
    MetaData *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        SharedPtr<MetaDataImpl > * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_SharedPtrTMetaDataImpl_t, 1);
        if (ptr) arg1 = *ptr;
    }
    result = (MetaData *)new MetaData(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_MetaData(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_MetaData__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_SharedPtrTMetaDataImpl_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_MetaData__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_MetaData'");
    return Qnil;
}


static void
free_MetaData(MetaData *arg1) {
    delete arg1;
}
static VALUE
_wrap_MetaData_get_impl(int argc, VALUE *argv, VALUE self) {
    MetaData *arg1 = (MetaData *) 0 ;
    SwigValueWrapper< SharedPtr<MetaDataImpl > > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_MetaData, 1);
    result = ((MetaData const *)arg1)->get_impl();
    
    {
        SharedPtr<MetaDataImpl > * resultptr;
        resultptr = new SharedPtr<MetaDataImpl >((SharedPtr<MetaDataImpl > &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_SharedPtrTMetaDataImpl_t, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Console_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Console_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Console);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Console(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    Console *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    result = (Console *)new Console((CL_Rect const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static void
free_Console(Console *arg1) {
    delete arg1;
}
static VALUE
_wrap_Console_write(int argc, VALUE *argv, VALUE self) {
    Console *arg1 = (Console *) 0 ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Console, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    (arg1)->write((std::string const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Console_clearscr(int argc, VALUE *argv, VALUE self) {
    Console *arg1 = (Console *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Console, 1);
    (arg1)->clearscr();
    
    return Qnil;
}


static VALUE
_wrap_new_Layer__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Layer *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Layer *)new Layer();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Layer_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Layer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Layer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Layer__SWIG_1(int argc, VALUE *argv, VALUE self) {
    SwigValueWrapper< SharedPtr<LayerImpl > > arg1 ;
    Layer *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        SharedPtr<LayerImpl > * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_SharedPtrTLayerImpl_t, 1);
        if (ptr) arg1 = *ptr;
    }
    result = (Layer *)new Layer(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Layer(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Layer__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_SharedPtrTLayerImpl_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Layer__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Layer'");
    return Qnil;
}


static void
free_Layer(Layer *arg1) {
    delete arg1;
}
static VALUE
_wrap_Layer_get_metadata(int argc, VALUE *argv, VALUE self) {
    Layer *arg1 = (Layer *) 0 ;
    MetaData result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Layer, 1);
    result = ((Layer const *)arg1)->get_metadata();
    
    {
        MetaData * resultptr;
        resultptr = new MetaData((MetaData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_MetaData, 1);
    }
    return vresult;
}


static VALUE
_wrap_Layer_set_metadata(int argc, VALUE *argv, VALUE self) {
    Layer *arg1 = (Layer *) 0 ;
    MetaData arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Layer, 1);
    {
        MetaData * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_MetaData, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->set_metadata(arg2);
    
    return Qnil;
}


static VALUE
_wrap_Layer_draw(int argc, VALUE *argv, VALUE self) {
    Layer *arg1 = (Layer *) 0 ;
    EditorMapComponent *arg2 = (EditorMapComponent *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Layer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_EditorMapComponent, 1);
    (arg1)->draw(arg2);
    
    return Qnil;
}


static VALUE
_wrap_Layer_has_bounding_rect(int argc, VALUE *argv, VALUE self) {
    Layer *arg1 = (Layer *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Layer, 1);
    result = (bool)((Layer const *)arg1)->has_bounding_rect();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Layer_get_bounding_rect(int argc, VALUE *argv, VALUE self) {
    Layer *arg1 = (Layer *) 0 ;
    SwigValueWrapper< CL_Rect > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Layer, 1);
    result = (arg1)->get_bounding_rect();
    
    {
        CL_Rect * resultptr;
        resultptr = new CL_Rect((CL_Rect &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Rect, 1);
    }
    return vresult;
}


static VALUE
_wrap_TilemapLayer_current(int argc, VALUE *argv, VALUE self) {
    TilemapLayer result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = TilemapLayer::current();
    
    {
        TilemapLayer * resultptr;
        resultptr = new TilemapLayer((TilemapLayer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_TilemapLayer, 1);
    }
    return vresult;
}


static VALUE
_wrap_TilemapLayer_set_current(int argc, VALUE *argv, VALUE self) {
    TilemapLayer arg1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        TilemapLayer * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_TilemapLayer, 1);
        if (ptr) arg1 = *ptr;
    }
    TilemapLayer::set_current(arg1);
    
    return Qnil;
}


static VALUE
_wrap_new_TilemapLayer__SWIG_0(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (TilemapLayer *)new TilemapLayer();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_TilemapLayer_allocate(VALUE self) {
#else
    static VALUE
    _wrap_TilemapLayer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TilemapLayer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_TilemapLayer__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Tileset arg1 ;
    int arg2 ;
    int arg3 ;
    TilemapLayer *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    {
        Tileset * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Tileset, 1);
        if (ptr) arg1 = *ptr;
    }
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    result = (TilemapLayer *)new TilemapLayer(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_TilemapLayer(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_TilemapLayer__SWIG_0(nargs, args, self);
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Tileset, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_TilemapLayer__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_TilemapLayer'");
    return Qnil;
}


static void
free_TilemapLayer(TilemapLayer *arg1) {
    delete arg1;
}
static VALUE
_wrap_TilemapLayer_draw(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    EditorMapComponent *arg2 = (EditorMapComponent *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_EditorMapComponent, 1);
    (arg1)->draw(arg2);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_get_tileset(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    Tileset result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (arg1)->get_tileset();
    
    {
        Tileset * resultptr;
        resultptr = new Tileset((Tileset &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Tileset, 1);
    }
    return vresult;
}


static VALUE
_wrap_TilemapLayer_get_tile(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    int arg2 ;
    int arg3 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    result = (int)(arg1)->get_tile(arg2,arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_TilemapLayer_get_field(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    Field<int > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (Field<int > *)(arg1)->get_field();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_FieldTint_t,0);
    return vresult;
}


static VALUE
_wrap_TilemapLayer_resize(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    CL_Size *arg2 = 0 ;
    CL_Point *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Size, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_CL_Point, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->resize((CL_Size const &)*arg2,(CL_Point const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_get_data(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    std::vector<int > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (arg1)->get_data();
    
    {
        vresult = rb_ary_new2((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        rb_ary_store(vresult,i,INT2NUM(((std::vector<int > &)result)[i]));
    }
    return vresult;
}


static VALUE
_wrap_TilemapLayer_set_data(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    std::vector<int > arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            arg2 = std::vector<int >(size);
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                if (FIXNUM_P(o))
                ((std::vector<int > &)arg2)[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            void *ptr;
            SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__vectorTint_t, 1);
            arg2 = *((std::vector<int > *) ptr);
        }
    }
    (arg1)->set_data(arg2);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_draw_tile__SWIG_0(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    TileBrush *arg2 = 0 ;
    CL_Point *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_TileBrush, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_CL_Point, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_tile((TileBrush const &)*arg2,(CL_Point const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_draw_tile__SWIG_1(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    int arg2 ;
    CL_Point *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_CL_Point, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_tile(arg2,(CL_Point const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_draw_tile__SWIG_2(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    bool arg5 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    arg4 = NUM2INT(argv[2]);
    arg5 = RTEST(argv[3]);
    (arg1)->draw_tile(arg2,arg3,arg4,arg5);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_get_width(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (int)((TilemapLayer const *)arg1)->get_width();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_TilemapLayer_get_height(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (int)((TilemapLayer const *)arg1)->get_height();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_TilemapLayer_set_background_color(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    CL_Color *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_background_color((CL_Color const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_set_foreground_color(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    CL_Color *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_foreground_color((CL_Color const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_set_draw_attribute(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    arg2 = RTEST(argv[0]);
    (arg1)->set_draw_attribute(arg2);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_get_draw_attribute(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (bool)((TilemapLayer const *)arg1)->get_draw_attribute();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_TilemapLayer_set_draw_grid(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    arg2 = RTEST(argv[0]);
    (arg1)->set_draw_grid(arg2);
    
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_get_draw_grid(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (bool)((TilemapLayer const *)arg1)->get_draw_grid();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_TilemapLayer_create_pixelbuffer(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    CL_PixelBuffer result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (arg1)->create_pixelbuffer();
    
    {
        CL_PixelBuffer * resultptr;
        resultptr = new CL_PixelBuffer((CL_PixelBuffer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_PixelBuffer, 1);
    }
    return vresult;
}


static VALUE
_wrap_TilemapLayer_draw_tile__SWIG_3(int argc, VALUE *argv, VALUE self) {
    Field<int > *arg1 = (Field<int > *) 0 ;
    TileBrush *arg2 = 0 ;
    CL_Point *arg3 = 0 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FieldTint_t, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_TileBrush, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_Point, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    TilemapLayer::draw_tile(arg1,(TileBrush const &)*arg2,(CL_Point const &)*arg3);
    
    return Qnil;
}


static VALUE _wrap_TilemapLayer_draw_tile(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[5];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 5); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_TilemapLayer, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_TileBrush, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_CL_Point, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_TilemapLayer_draw_tile__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_TilemapLayer, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_CL_Point, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_TilemapLayer_draw_tile__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_FieldTint_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_TileBrush, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_CL_Point, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_TilemapLayer_draw_tile__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_TilemapLayer, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_TilemapLayer_draw_tile__SWIG_2(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'TilemapLayer_draw_tile'");
    return Qnil;
}


static VALUE
_wrap_TilemapLayer_has_bounding_rect(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (bool)((TilemapLayer const *)arg1)->has_bounding_rect();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_TilemapLayer_get_bounding_rect(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    SwigValueWrapper< CL_Rect > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (arg1)->get_bounding_rect();
    
    {
        CL_Rect * resultptr;
        resultptr = new CL_Rect((CL_Rect &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Rect, 1);
    }
    return vresult;
}


static VALUE
_wrap_TilemapLayer_world2tile(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    CL_Point *arg2 = 0 ;
    SwigValueWrapper< CL_Point > result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = ((TilemapLayer const *)arg1)->world2tile((CL_Point const &)*arg2);
    
    {
        CL_Point * resultptr;
        resultptr = new CL_Point((CL_Point &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Point, 1);
    }
    return vresult;
}


static VALUE
_wrap_TilemapLayer_is_null(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (bool)((TilemapLayer const *)arg1)->is_null();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_TilemapLayer_to_layer(int argc, VALUE *argv, VALUE self) {
    TilemapLayer *arg1 = (TilemapLayer *) 0 ;
    Layer result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TilemapLayer, 1);
    result = (arg1)->to_layer();
    
    {
        Layer * resultptr;
        resultptr = new Layer((Layer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Layer, 1);
    }
    return vresult;
}


static VALUE
ObjectLayer_current__get(VALUE self) {
    VALUE _val;
    
    _val = SWIG_NewPointerObj((void *) &ObjectLayer::current_, SWIGTYPE_p_ObjectLayer, 1);    return _val;
}


static VALUE
ObjectLayer_current__set(VALUE self, VALUE _val) {
    {
        ObjectLayer * ptr;
        SWIG_ConvertPtr(_val, (void **) &ptr, SWIGTYPE_p_ObjectLayer, 1);
        if (ptr) ObjectLayer::current_ = *ptr;
    }
    return _val;
}


static VALUE
_wrap_ObjectLayer_current(int argc, VALUE *argv, VALUE self) {
    ObjectLayer result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = ObjectLayer::current();
    
    {
        ObjectLayer * resultptr;
        resultptr = new ObjectLayer((ObjectLayer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ObjectLayer, 1);
    }
    return vresult;
}


static VALUE
_wrap_ObjectLayer_set_current(int argc, VALUE *argv, VALUE self) {
    ObjectLayer arg1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        ObjectLayer * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ObjectLayer, 1);
        if (ptr) arg1 = *ptr;
    }
    ObjectLayer::set_current(arg1);
    
    return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjectLayer_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjectLayer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjectLayer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjectLayer(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (ObjectLayer *)new ObjectLayer();
    DATA_PTR(self) = result;
    return self;
}


static void
free_ObjectLayer(ObjectLayer *arg1) {
    delete arg1;
}
static VALUE
_wrap_ObjectLayer_add_object(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = (ObjectLayer *) 0 ;
    ObjMapObject *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_object((ObjMapObject const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjectLayer_delete_object(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = (ObjectLayer *) 0 ;
    ObjMapObject *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->delete_object((ObjMapObject const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjectLayer_find_object(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = (ObjectLayer *) 0 ;
    CL_Point *arg2 = 0 ;
    ObjMapObject result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->find_object((CL_Point const &)*arg2);
    
    {
        ObjMapObject * resultptr;
        resultptr = new ObjMapObject((ObjMapObject &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ObjMapObject, 1);
    }
    return vresult;
}


static VALUE
_wrap_ObjectLayer_get_selection(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = (ObjectLayer *) 0 ;
    CL_Rect *arg2 = 0 ;
    std::vector<ObjMapObject > result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Rect, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->get_selection((CL_Rect const &)*arg2);
    
    {
        vresult = rb_ary_new2((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++) {
            ObjMapObject* x = new ObjMapObject(((std::vector<ObjMapObject > &)result)[i]);
            rb_ary_store(vresult,i,
            SWIG_NewPointerObj((void *) x, 
            SWIGTYPE_p_ObjMapObject, 1));
        }
    }
    return vresult;
}


static VALUE
_wrap_ObjectLayer_get_objects(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = (ObjectLayer *) 0 ;
    std::vector<ObjMapObject > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1);
    result = (arg1)->get_objects();
    
    {
        vresult = rb_ary_new2((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++) {
            ObjMapObject* x = new ObjMapObject(((std::vector<ObjMapObject > &)result)[i]);
            rb_ary_store(vresult,i,
            SWIG_NewPointerObj((void *) x, 
            SWIGTYPE_p_ObjMapObject, 1));
        }
    }
    return vresult;
}


static VALUE
_wrap_ObjectLayer_to_layer(int argc, VALUE *argv, VALUE self) {
    ObjectLayer *arg1 = (ObjectLayer *) 0 ;
    Layer result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectLayer, 1);
    result = (arg1)->to_layer();
    
    {
        Layer * resultptr;
        resultptr = new Layer((Layer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Layer, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_EditorMap_allocate(VALUE self) {
#else
    static VALUE
    _wrap_EditorMap_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_EditorMap);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_EditorMap(int argc, VALUE *argv, VALUE self) {
    EditorMap *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (EditorMap *)new EditorMap();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_EditorMap_draw(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    EditorMapComponent *arg2 = (EditorMapComponent *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_EditorMapComponent, 1);
    (arg1)->draw(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_add_layer(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    Layer *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Layer, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_layer((Layer const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_is_modified(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    result = (bool)((EditorMap const *)arg1)->is_modified();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_EditorMap_set_unmodified(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    (arg1)->set_unmodified();
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_modify(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    (arg1)->modify();
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_get_serial(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    result = (int)((EditorMap const *)arg1)->get_serial();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EditorMap_get_layer(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    int arg2 ;
    Layer result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    arg2 = NUM2INT(argv[0]);
    result = (arg1)->get_layer(arg2);
    
    {
        Layer * resultptr;
        resultptr = new Layer((Layer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Layer, 1);
    }
    return vresult;
}


static VALUE
_wrap_EditorMap_set_metadata(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    MetaData *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_MetaData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_metadata((MetaData const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_get_metadata(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    MetaData result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    result = ((EditorMap const *)arg1)->get_metadata();
    
    {
        MetaData * resultptr;
        resultptr = new MetaData((MetaData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_MetaData, 1);
    }
    return vresult;
}


static VALUE
_wrap_EditorMap_has_bounding_rect(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    result = (bool)((EditorMap const *)arg1)->has_bounding_rect();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_EditorMap_get_bounding_rect(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    SwigValueWrapper< CL_Rect > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    result = (arg1)->get_bounding_rect();
    
    {
        CL_Rect * resultptr;
        resultptr = new CL_Rect((CL_Rect &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Rect, 1);
    }
    return vresult;
}


static VALUE
_wrap_EditorMap_set_background_color(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    CL_Color *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_background_color((CL_Color const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_execute(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    Command arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    {
        Command * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Command, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->execute(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_undo(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    (arg1)->undo();
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_redo(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    (arg1)->redo();
    
    return Qnil;
}


static VALUE
_wrap_EditorMap_undo_stack_size(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    result = (int)(arg1)->undo_stack_size();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EditorMap_redo_stack_size(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    result = (int)(arg1)->redo_stack_size();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EditorMap_sig_change(int argc, VALUE *argv, VALUE self) {
    EditorMap *arg1 = (EditorMap *) 0 ;
    CL_Signal_v0 *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMap, 1);
    {
        CL_Signal_v0 &_result_ref = (arg1)->sig_change();
        result = (CL_Signal_v0 *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v0,0);
    return vresult;
}


static void
free_EditorMap(EditorMap *arg1) {
    delete arg1;
}
static VALUE
_wrap_Workspace_set_current(int argc, VALUE *argv, VALUE self) {
    Workspace arg1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        Workspace * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Workspace, 1);
        if (ptr) arg1 = *ptr;
    }
    Workspace::set_current(arg1);
    
    return Qnil;
}


static VALUE
_wrap_Workspace_current(int argc, VALUE *argv, VALUE self) {
    Workspace result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = Workspace::current();
    
    {
        Workspace * resultptr;
        resultptr = new Workspace((Workspace &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Workspace, 1);
    }
    return vresult;
}


static VALUE
_wrap_new_Workspace__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Workspace *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Workspace *)new Workspace();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Workspace_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Workspace_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Workspace);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Workspace__SWIG_1(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    int arg2 ;
    Workspace *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2INT(argv[0]);
    arg2 = NUM2INT(argv[1]);
    result = (Workspace *)new Workspace(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Workspace(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Workspace__SWIG_0(nargs, args, self);
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Workspace__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Workspace'");
    return Qnil;
}


static VALUE
_wrap_Workspace_draw(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    (arg1)->draw();
    
    return Qnil;
}


static VALUE
_wrap_Workspace_mouse_up(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    CL_InputEvent *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_InputEvent, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->mouse_up((CL_InputEvent const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Workspace_mouse_down(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    CL_InputEvent *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_InputEvent, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->mouse_down((CL_InputEvent const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Workspace_mouse_move(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    CL_InputEvent *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_InputEvent, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->mouse_move((CL_InputEvent const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Workspace_get_map(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    EditorMap result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    result = (arg1)->get_map();
    
    {
        EditorMap * resultptr;
        resultptr = new EditorMap((EditorMap &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_EditorMap, 1);
    }
    return vresult;
}


static VALUE
_wrap_Workspace_set_map(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    EditorMap *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_EditorMap, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_map((EditorMap const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Workspace_get_gc_state(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    GraphicContextState *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    {
        GraphicContextState &_result_ref = (arg1)->get_gc_state();
        result = (GraphicContextState *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_GraphicContextState,0);
    return vresult;
}


static VALUE
_wrap_Workspace_set_tool(int argc, VALUE *argv, VALUE self) {
    Workspace *arg1 = (Workspace *) 0 ;
    Tool *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Workspace, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Tool, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_tool((Tool const &)*arg2);
    
    return Qnil;
}


static void
free_Workspace(Workspace *arg1) {
    delete arg1;
}
static VALUE
_wrap_new_Tileset__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Tileset *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Tileset *)new Tileset();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Tileset_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Tileset_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Tileset);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Tileset__SWIG_1(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    Tileset *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = NUM2INT(argv[0]);
    result = (Tileset *)new Tileset(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Tileset(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Tileset__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Tileset__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Tileset'");
    return Qnil;
}


static void
free_Tileset(Tileset *arg1) {
    delete arg1;
}
static VALUE
_wrap_Tileset_create(int argc, VALUE *argv, VALUE self) {
    Tileset *arg1 = (Tileset *) 0 ;
    int arg2 ;
    Tile *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tileset, 1);
    arg2 = NUM2INT(argv[0]);
    result = (Tile *)(arg1)->create(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Tile,0);
    return vresult;
}


static VALUE
_wrap_Tileset_get_tile_size(int argc, VALUE *argv, VALUE self) {
    Tileset *arg1 = (Tileset *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tileset, 1);
    result = (int)((Tileset const *)arg1)->get_tile_size();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Tileset_add_tile(int argc, VALUE *argv, VALUE self) {
    Tileset *arg1 = (Tileset *) 0 ;
    int arg2 ;
    Tile *arg3 = (Tile *) 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tileset, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Tile, 1);
    (arg1)->add_tile(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_Tileset_get_tiles(int argc, VALUE *argv, VALUE self) {
    Tileset *arg1 = (Tileset *) 0 ;
    std::vector<int > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Tileset, 1);
    result = ((Tileset const *)arg1)->get_tiles();
    
    {
        vresult = rb_ary_new2((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        rb_ary_store(vresult,i,INT2NUM(((std::vector<int > &)result)[i]));
    }
    return vresult;
}


static VALUE
_wrap_EditorMapComponent_current(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (EditorMapComponent *)EditorMapComponent::current();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_EditorMapComponent,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_EditorMapComponent_allocate(VALUE self) {
#else
    static VALUE
    _wrap_EditorMapComponent_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_EditorMapComponent);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_EditorMapComponent(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    EditorMapComponent *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    result = (EditorMapComponent *)new EditorMapComponent((CL_Rect const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static void
free_EditorMapComponent(EditorMapComponent *arg1) {
    delete arg1;
}
static VALUE
_wrap_EditorMapComponent_get_workspace(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    Workspace result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    result = ((EditorMapComponent const *)arg1)->get_workspace();
    
    {
        Workspace * resultptr;
        resultptr = new Workspace((Workspace &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Workspace, 1);
    }
    return vresult;
}


static VALUE
_wrap_EditorMapComponent_set_workspace(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    Workspace arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    {
        Workspace * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Workspace, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->set_workspace(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_set_zoom(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    (arg1)->set_zoom(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_zoom_to(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    SwigValueWrapper< CL_Rect > arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    {
        CL_Rect * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_CL_Rect, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->zoom_to(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_zoom_out(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    SwigValueWrapper< CL_Point > arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    {
        CL_Point * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_CL_Point, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->zoom_out(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_zoom_in(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    SwigValueWrapper< CL_Point > arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    {
        CL_Point * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_CL_Point, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->zoom_in(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_move_to(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    int arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    (arg1)->move_to(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_move_to_x(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    (arg1)->move_to_x(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_move_to_y(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    (arg1)->move_to_y(arg2);
    
    return Qnil;
}


static VALUE
_wrap_EditorMapComponent_sig_on_key(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    std::string *arg2 = 0 ;
    CL_Signal_v2<int,int > *result;
    std::string temp2 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        CL_Signal_v2<int,int > &_result_ref = (arg1)->sig_on_key((std::string const &)*arg2);
        result = (CL_Signal_v2<int,int > *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v2Tint_int_t,0);
    return vresult;
}


static VALUE
_wrap_EditorMapComponent_screen2world(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    CL_Point *arg2 = 0 ;
    SwigValueWrapper< CL_Point > result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->screen2world((CL_Point const &)*arg2);
    
    {
        CL_Point * resultptr;
        resultptr = new CL_Point((CL_Point &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Point, 1);
    }
    return vresult;
}


static VALUE
_wrap_EditorMapComponent_get_clip_rect(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    SwigValueWrapper< CL_Rect > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    result = (arg1)->get_clip_rect();
    
    {
        CL_Rect * resultptr;
        resultptr = new CL_Rect((CL_Rect &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Rect, 1);
    }
    return vresult;
}


static VALUE
_wrap_Flexlay_screen_width_set(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->screen_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Flexlay_screen_width_get(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    result = (int) ((arg1)->screen_width);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Flexlay_screen_height_set(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->screen_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Flexlay_screen_height_get(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    result = (int) ((arg1)->screen_height);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Flexlay_fullscreen_set(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    arg2 = RTEST(argv[0]);
    if (arg1) (arg1)->fullscreen = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Flexlay_fullscreen_get(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    result = (bool) ((arg1)->fullscreen);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Flexlay_allow_resize_set(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    arg2 = RTEST(argv[0]);
    if (arg1) (arg1)->allow_resize = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Flexlay_allow_resize_get(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    result = (bool) ((arg1)->allow_resize);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Flexlay_use_opengl_set(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    arg2 = RTEST(argv[0]);
    if (arg1) (arg1)->use_opengl = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Flexlay_use_opengl_get(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    result = (bool) ((arg1)->use_opengl);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Flexlay_resources_set(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    CL_ResourceManager *arg2 = (CL_ResourceManager *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_ResourceManager, 1);
    if (arg1) (arg1)->resources = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Flexlay_resources_get(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    CL_ResourceManager *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    result = (CL_ResourceManager *)& ((arg1)->resources);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_ResourceManager,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Flexlay_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Flexlay_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Flexlay);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Flexlay(int argc, VALUE *argv, VALUE self) {
    Flexlay *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Flexlay *)new Flexlay();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_Flexlay_init(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    (arg1)->init();
    
    return Qnil;
}


static VALUE
_wrap_Flexlay_deinit(int argc, VALUE *argv, VALUE self) {
    Flexlay *arg1 = (Flexlay *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Flexlay, 1);
    (arg1)->deinit();
    
    return Qnil;
}


static void
free_Flexlay(Flexlay *arg1) {
    delete arg1;
}
static VALUE
datadir_get(VALUE self) {
    VALUE _val;
    
    _val = SWIG_NewPointerObj((void *) &datadir, SWIGTYPE_p_std__string, 1);    return _val;
}


static VALUE
datadir_set(VALUE self, VALUE _val) {
    {
        std::string * ptr;
        SWIG_ConvertPtr(_val, (void **) &ptr, SWIGTYPE_p_std__string, 1);
        if (ptr) datadir = *ptr;
    }
    return _val;
}


static VALUE
bindir_get(VALUE self) {
    VALUE _val;
    
    _val = SWIG_NewPointerObj((void *) &bindir, SWIGTYPE_p_std__string, 1);    return _val;
}


static VALUE
bindir_set(VALUE self, VALUE _val) {
    {
        std::string * ptr;
        SWIG_ConvertPtr(_val, (void **) &ptr, SWIGTYPE_p_std__string, 1);
        if (ptr) bindir = *ptr;
    }
    return _val;
}


static VALUE
homedir_get(VALUE self) {
    VALUE _val;
    
    _val = SWIG_NewPointerObj((void *) &homedir, SWIGTYPE_p_std__string, 1);    return _val;
}


static VALUE
homedir_set(VALUE self, VALUE _val) {
    {
        std::string * ptr;
        SWIG_ConvertPtr(_val, (void **) &ptr, SWIGTYPE_p_std__string, 1);
        if (ptr) homedir = *ptr;
    }
    return _val;
}


static VALUE
debug_get(VALUE self) {
    VALUE _val;
    
    _val = INT2NUM(debug);    return _val;
}


static VALUE
debug_set(VALUE self, VALUE _val) {
    debug = NUM2INT(_val);
    return _val;
}


static VALUE
_wrap_GUIManager_current(int argc, VALUE *argv, VALUE self) {
    GUIManager *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (GUIManager *)GUIManager::current();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_GUIManager,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_GUIManager_allocate(VALUE self) {
#else
    static VALUE
    _wrap_GUIManager_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_GUIManager);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_GUIManager(int argc, VALUE *argv, VALUE self) {
    GUIManager *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (GUIManager *)new GUIManager();
    DATA_PTR(self) = result;
    return self;
}


static void
free_GUIManager(GUIManager *arg1) {
    delete arg1;
}
static VALUE
_wrap_GUIManager_draw(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    (arg1)->draw();
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_update(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    (arg1)->update();
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_run(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    (arg1)->run();
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_quit(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    (arg1)->quit();
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_push_component(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    (arg1)->push_component(arg2);
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_pop_component(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    (arg1)->pop_component();
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_hide(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    (arg1)->hide();
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_show(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    (arg1)->show();
    
    return Qnil;
}


static VALUE
_wrap_GUIManager_is_visible(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    result = (bool)(arg1)->is_visible();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_GUIManager_get_component(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    CL_Component *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    result = (CL_Component *)(arg1)->get_component();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Component,0);
    return vresult;
}


static VALUE
_wrap_GUIManager_get_slot_container(int argc, VALUE *argv, VALUE self) {
    GUIManager *arg1 = (GUIManager *) 0 ;
    CL_SlotContainer *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GUIManager, 1);
    result = (CL_SlotContainer *)(arg1)->get_slot_container();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_SlotContainer,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_TileSelector_allocate(VALUE self) {
#else
    static VALUE
    _wrap_TileSelector_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TileSelector);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_TileSelector(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    TileSelector *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    result = (TileSelector *)new TileSelector((CL_Rect const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static void
free_TileSelector(TileSelector *arg1) {
    delete arg1;
}
static VALUE
_wrap_TileSelector_set_tileset(int argc, VALUE *argv, VALUE self) {
    TileSelector *arg1 = (TileSelector *) 0 ;
    Tileset arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileSelector, 1);
    {
        Tileset * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Tileset, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->set_tileset(arg2);
    
    return Qnil;
}


static VALUE
_wrap_TileSelector_set_tiles(int argc, VALUE *argv, VALUE self) {
    TileSelector *arg1 = (TileSelector *) 0 ;
    TileSelector::Tiles *arg2 = 0 ;
    std::vector<int > temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileSelector, 1);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            temp2 = std::vector<int >(size);
            arg2 = &temp2;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                if (FIXNUM_P(o))
                temp2[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_TileSelector__Tiles, 1);
        }
    }
    (arg1)->set_tiles((TileSelector::Tiles const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_TileSelector_get_tiles(int argc, VALUE *argv, VALUE self) {
    TileSelector *arg1 = (TileSelector *) 0 ;
    TileSelector::Tiles result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileSelector, 1);
    result = ((TileSelector const *)arg1)->get_tiles();
    
    {
        vresult = rb_ary_new2((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        rb_ary_store(vresult,i,INT2NUM(((TileSelector::Tiles &)result)[i]));
    }
    return vresult;
}


static VALUE
_wrap_TileSelector_set_scale(int argc, VALUE *argv, VALUE self) {
    TileSelector *arg1 = (TileSelector *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileSelector, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    (arg1)->set_scale(arg2);
    
    return Qnil;
}


static VALUE
_wrap_TileSelector_draw(int argc, VALUE *argv, VALUE self) {
    TileSelector *arg1 = (TileSelector *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileSelector, 1);
    (arg1)->draw();
    
    return Qnil;
}


static VALUE
_wrap_new_ObjectBrush__SWIG_0(int argc, VALUE *argv, VALUE self) {
    ObjectBrush *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (ObjectBrush *)new ObjectBrush();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjectBrush_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjectBrush_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjectBrush);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjectBrush__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CL_Sprite *arg1 = 0 ;
    MetaData *arg2 = 0 ;
    ObjectBrush *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Sprite, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_MetaData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjectBrush *)new ObjectBrush((CL_Sprite const &)*arg1,(MetaData const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_ObjectBrush(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_ObjectBrush__SWIG_0(nargs, args, self);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_Sprite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_MetaData, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_ObjectBrush__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_ObjectBrush'");
    return Qnil;
}


static VALUE
_wrap_ObjectBrush_get_sprite(int argc, VALUE *argv, VALUE self) {
    ObjectBrush *arg1 = (ObjectBrush *) 0 ;
    CL_Sprite result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectBrush, 1);
    result = (arg1)->get_sprite();
    
    {
        CL_Sprite * resultptr;
        resultptr = new CL_Sprite((CL_Sprite &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Sprite, 1);
    }
    return vresult;
}


static VALUE
_wrap_ObjectBrush_get_data(int argc, VALUE *argv, VALUE self) {
    ObjectBrush *arg1 = (ObjectBrush *) 0 ;
    MetaData result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectBrush, 1);
    result = (arg1)->get_data();
    
    {
        MetaData * resultptr;
        resultptr = new MetaData((MetaData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_MetaData, 1);
    }
    return vresult;
}


static VALUE
_wrap_ObjectBrush_to_sprite_object(int argc, VALUE *argv, VALUE self) {
    ObjectBrush *arg1 = (ObjectBrush *) 0 ;
    CL_Point *arg2 = 0 ;
    ObjMapSpriteObject result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectBrush, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->to_sprite_object((CL_Point const &)*arg2);
    
    {
        ObjMapSpriteObject * resultptr;
        resultptr = new ObjMapSpriteObject((ObjMapSpriteObject &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ObjMapSpriteObject, 1);
    }
    return vresult;
}


static void
free_ObjectBrush(ObjectBrush *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjectSelector_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjectSelector_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjectSelector);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjectSelector(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    int arg2 ;
    int arg3 ;
    CL_Component *arg4 = (CL_Component *) 0 ;
    ObjectSelector *result;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_CL_Component, 1);
    result = (ObjectSelector *)new ObjectSelector((CL_Rect const &)*arg1,arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


static void
free_ObjectSelector(ObjectSelector *arg1) {
    delete arg1;
}
static VALUE
_wrap_ObjectSelector_draw(int argc, VALUE *argv, VALUE self) {
    ObjectSelector *arg1 = (ObjectSelector *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectSelector, 1);
    (arg1)->draw();
    
    return Qnil;
}


static VALUE
_wrap_ObjectSelector_add_brush(int argc, VALUE *argv, VALUE self) {
    ObjectSelector *arg1 = (ObjectSelector *) 0 ;
    ObjectBrush *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectSelector, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjectBrush, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_brush((ObjectBrush const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjectSelector_sig_drop(int argc, VALUE *argv, VALUE self) {
    ObjectSelector *arg1 = (ObjectSelector *) 0 ;
    CL_Signal_v1<ObjMapObject > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjectSelector, 1);
    {
        CL_Signal_v1<ObjMapObject > &_result_ref = (arg1)->sig_drop();
        result = (CL_Signal_v1<ObjMapObject > *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v1TObjMapObject_t,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Icon_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Icon_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Icon);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Icon(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Sprite *arg2 = 0 ;
    std::string *arg3 = 0 ;
    CL_Component *arg4 = (CL_Component *) 0 ;
    Icon *result;
    std::string temp3 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Sprite, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    {
        if (TYPE(argv[2]) == T_STRING) {
            temp3 = std::string(StringValuePtr(argv[2]));
            arg3 = &temp3;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_CL_Component, 1);
    result = (Icon *)new Icon((CL_Rect const &)*arg1,(CL_Sprite const &)*arg2,(std::string const &)*arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_Icon_disable(int argc, VALUE *argv, VALUE self) {
    Icon *arg1 = (Icon *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Icon, 1);
    (arg1)->disable();
    
    return Qnil;
}


static VALUE
_wrap_Icon_enable(int argc, VALUE *argv, VALUE self) {
    Icon *arg1 = (Icon *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Icon, 1);
    (arg1)->enable();
    
    return Qnil;
}


static VALUE
_wrap_Icon_set_up(int argc, VALUE *argv, VALUE self) {
    Icon *arg1 = (Icon *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Icon, 1);
    (arg1)->set_up();
    
    return Qnil;
}


static VALUE
_wrap_Icon_set_down(int argc, VALUE *argv, VALUE self) {
    Icon *arg1 = (Icon *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Icon, 1);
    (arg1)->set_down();
    
    return Qnil;
}


static VALUE
_wrap_Icon_sig_clicked(int argc, VALUE *argv, VALUE self) {
    Icon *arg1 = (Icon *) 0 ;
    CL_Signal_v0 *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Icon, 1);
    {
        CL_Signal_v0 &_result_ref = (arg1)->sig_clicked();
        result = (CL_Signal_v0 *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v0,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Window_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Window_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Window);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Window(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    std::string *arg2 = 0 ;
    CL_Component *arg3 = (CL_Component *) 0 ;
    Window *result;
    std::string temp2 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[1]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_Component, 1);
    result = (Window *)new Window((CL_Rect const &)*arg1,(std::string const &)*arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static void
free_Window(Window *arg1) {
    delete arg1;
}
static VALUE
_wrap_Window_hide(int argc, VALUE *argv, VALUE self) {
    Window *arg1 = (Window *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Window, 1);
    (arg1)->hide();
    
    return Qnil;
}


static VALUE
_wrap_Window_show(int argc, VALUE *argv, VALUE self) {
    Window *arg1 = (Window *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Window, 1);
    (arg1)->show();
    
    return Qnil;
}


static VALUE
_wrap_Window_get_client_area(int argc, VALUE *argv, VALUE self) {
    Window *arg1 = (Window *) 0 ;
    CL_Component *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Window, 1);
    result = (CL_Component *)(arg1)->get_client_area();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Component,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Panel_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Panel_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Panel);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Panel(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    Panel *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    result = (Panel *)new Panel((CL_Rect const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Minimap_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Minimap_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Minimap);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Minimap(int argc, VALUE *argv, VALUE self) {
    EditorMapComponent *arg1 = (EditorMapComponent *) 0 ;
    CL_Rect *arg2 = 0 ;
    CL_Component *arg3 = (CL_Component *) 0 ;
    Minimap *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_EditorMapComponent, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Rect, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_Component, 1);
    result = (Minimap *)new Minimap(arg1,(CL_Rect const &)*arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_Minimap_draw(int argc, VALUE *argv, VALUE self) {
    Minimap *arg1 = (Minimap *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Minimap, 1);
    (arg1)->draw();
    
    return Qnil;
}


static VALUE
_wrap_Minimap_update_minimap(int argc, VALUE *argv, VALUE self) {
    Minimap *arg1 = (Minimap *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Minimap, 1);
    (arg1)->update_minimap();
    
    return Qnil;
}


static VALUE
_wrap_Minimap_mouse_move(int argc, VALUE *argv, VALUE self) {
    Minimap *arg1 = (Minimap *) 0 ;
    CL_InputEvent *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Minimap, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_InputEvent, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->mouse_move((CL_InputEvent const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Minimap_mouse_down(int argc, VALUE *argv, VALUE self) {
    Minimap *arg1 = (Minimap *) 0 ;
    CL_InputEvent *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Minimap, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_InputEvent, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->mouse_down((CL_InputEvent const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_Minimap_mouse_up(int argc, VALUE *argv, VALUE self) {
    Minimap *arg1 = (Minimap *) 0 ;
    CL_InputEvent *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Minimap, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_InputEvent, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->mouse_up((CL_InputEvent const &)*arg2);
    
    return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_DirectoryView_allocate(VALUE self) {
#else
    static VALUE
    _wrap_DirectoryView_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_DirectoryView);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_DirectoryView(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    DirectoryView *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    result = (DirectoryView *)new DirectoryView((CL_Rect const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static void
free_DirectoryView(DirectoryView *arg1) {
    delete arg1;
}
static VALUE
_wrap_DirectoryView_set_directory(int argc, VALUE *argv, VALUE self) {
    DirectoryView *arg1 = (DirectoryView *) 0 ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_DirectoryView, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    (arg1)->set_directory((std::string const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_DirectoryView_sig_on_click(int argc, VALUE *argv, VALUE self) {
    DirectoryView *arg1 = (DirectoryView *) 0 ;
    CL_Signal_v1<std::string > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_DirectoryView, 1);
    {
        CL_Signal_v1<std::string > &_result_ref = (arg1)->sig_on_click();
        result = (CL_Signal_v1<std::string > *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v1Tstd__string_t,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Menu_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Menu_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Menu);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Menu(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    Menu *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Point, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    result = (Menu *)new Menu((CL_Point const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static void
free_Menu(Menu *arg1) {
    delete arg1;
}
static VALUE
_wrap_Menu_clear(int argc, VALUE *argv, VALUE self) {
    Menu *arg1 = (Menu *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Menu, 1);
    (arg1)->clear();
    
    return Qnil;
}


static VALUE
_wrap_Menu_add_item(int argc, VALUE *argv, VALUE self) {
    Menu *arg1 = (Menu *) 0 ;
    CL_Sprite *arg2 = 0 ;
    std::string *arg3 = 0 ;
    MenuItemHandle result;
    std::string temp3 ;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Menu, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Sprite, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp3 = std::string(StringValuePtr(argv[1]));
            arg3 = &temp3;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    result = (MenuItemHandle)(arg1)->add_item((CL_Sprite const &)*arg2,(std::string const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Menu_add_submenu(int argc, VALUE *argv, VALUE self) {
    Menu *arg1 = (Menu *) 0 ;
    std::string *arg2 = 0 ;
    Menu *arg3 = 0 ;
    MenuItemHandle result;
    std::string temp2 ;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Menu, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Menu, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (MenuItemHandle)(arg1)->add_submenu((std::string const &)*arg2,(Menu const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Menu_add_seperator(int argc, VALUE *argv, VALUE self) {
    Menu *arg1 = (Menu *) 0 ;
    MenuItemHandle result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Menu, 1);
    result = (MenuItemHandle)(arg1)->add_seperator();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Menu_sig_clicked(int argc, VALUE *argv, VALUE self) {
    Menu *arg1 = (Menu *) 0 ;
    MenuItemHandle arg2 ;
    CL_Signal_v0 *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Menu, 1);
    arg2 = NUM2INT(argv[0]);
    {
        CL_Signal_v0 &_result_ref = (arg1)->sig_clicked(arg2);
        result = (CL_Signal_v0 *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v0,0);
    return vresult;
}


static VALUE
_wrap_Menu_run(int argc, VALUE *argv, VALUE self) {
    Menu *arg1 = (Menu *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Menu, 1);
    (arg1)->run();
    
    return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Menubar_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Menubar_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Menubar);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Menubar(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = 0 ;
    CL_Component *arg2 = (CL_Component *) 0 ;
    Menubar *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Point, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Component, 1);
    result = (Menubar *)new Menubar((CL_Point const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_Menubar_add_submenu(int argc, VALUE *argv, VALUE self) {
    Menubar *arg1 = (Menubar *) 0 ;
    std::string *arg2 = 0 ;
    Menu *arg3 = 0 ;
    std::string temp2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Menubar, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Menu, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_submenu((std::string const &)*arg2,(Menu const &)*arg3);
    
    return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Scrollbar_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Scrollbar_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Scrollbar);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Scrollbar(int argc, VALUE *argv, VALUE self) {
    CL_Rect *arg1 = 0 ;
    int arg2 ;
    CL_Component *arg3 = (CL_Component *) 0 ;
    Scrollbar *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Rect, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg2 = (int) NUM2INT(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_CL_Component, 1);
    result = (Scrollbar *)new Scrollbar((CL_Rect const &)*arg1,(Scrollbar::Orientation )arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_Scrollbar_set_range(int argc, VALUE *argv, VALUE self) {
    Scrollbar *arg1 = (Scrollbar *) 0 ;
    float arg2 ;
    float arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Scrollbar, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    arg3 = (float) NUM2DBL(argv[1]);
    (arg1)->set_range(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_Scrollbar_set_pagesize(int argc, VALUE *argv, VALUE self) {
    Scrollbar *arg1 = (Scrollbar *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Scrollbar, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    (arg1)->set_pagesize(arg2);
    
    return Qnil;
}


static VALUE
_wrap_Scrollbar_set_pos(int argc, VALUE *argv, VALUE self) {
    Scrollbar *arg1 = (Scrollbar *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Scrollbar, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    (arg1)->set_pos(arg2);
    
    return Qnil;
}


static VALUE
_wrap_Scrollbar_sig_scrollbar_move(int argc, VALUE *argv, VALUE self) {
    Scrollbar *arg1 = (Scrollbar *) 0 ;
    CL_Signal_v1<float > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Scrollbar, 1);
    {
        CL_Signal_v1<float > &_result_ref = (arg1)->sig_scrollbar_move();
        result = (CL_Signal_v1<float > *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v1Tfloat_t,0);
    return vresult;
}


static VALUE
_wrap_TileMapPaintTool_current(int argc, VALUE *argv, VALUE self) {
    TileMapPaintTool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = TileMapPaintTool::current();
    
    {
        TileMapPaintTool * resultptr;
        resultptr = new TileMapPaintTool((TileMapPaintTool &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_TileMapPaintTool, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_TileMapPaintTool_allocate(VALUE self) {
#else
    static VALUE
    _wrap_TileMapPaintTool_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TileMapPaintTool);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_TileMapPaintTool(int argc, VALUE *argv, VALUE self) {
    TileMapPaintTool *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (TileMapPaintTool *)new TileMapPaintTool();
    DATA_PTR(self) = result;
    return self;
}


static void
free_TileMapPaintTool(TileMapPaintTool *arg1) {
    delete arg1;
}
static VALUE
_wrap_TileMapPaintTool_get_brush(int argc, VALUE *argv, VALUE self) {
    TileMapPaintTool *arg1 = (TileMapPaintTool *) 0 ;
    TileBrush *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileMapPaintTool, 1);
    {
        TileBrush const &_result_ref = (arg1)->get_brush();
        result = (TileBrush *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_TileBrush,0);
    return vresult;
}


static VALUE
_wrap_TileMapPaintTool_set_brush(int argc, VALUE *argv, VALUE self) {
    TileMapPaintTool *arg1 = (TileMapPaintTool *) 0 ;
    TileBrush *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileMapPaintTool, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_TileBrush, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_brush((TileBrush const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_TileMapPaintTool_to_tool(int argc, VALUE *argv, VALUE self) {
    TileMapPaintTool *arg1 = (TileMapPaintTool *) 0 ;
    Tool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileMapPaintTool, 1);
    result = (arg1)->to_tool();
    
    {
        Tool * resultptr;
        resultptr = new Tool((Tool &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Tool, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_TileMapSelectTool_allocate(VALUE self) {
#else
    static VALUE
    _wrap_TileMapSelectTool_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TileMapSelectTool);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_TileMapSelectTool(int argc, VALUE *argv, VALUE self) {
    TileMapSelectTool *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (TileMapSelectTool *)new TileMapSelectTool();
    DATA_PTR(self) = result;
    return self;
}


static void
free_TileMapSelectTool(TileMapSelectTool *arg1) {
    delete arg1;
}
static VALUE
_wrap_TileMapSelectTool_get_selection(int argc, VALUE *argv, VALUE self) {
    TileMapSelectTool *arg1 = (TileMapSelectTool *) 0 ;
    TileBrush result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileMapSelectTool, 1);
    result = ((TileMapSelectTool const *)arg1)->get_selection();
    
    {
        TileBrush * resultptr;
        resultptr = new TileBrush((TileBrush &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_TileBrush, 1);
    }
    return vresult;
}


static VALUE
_wrap_TileMapSelectTool_get_selection_rect(int argc, VALUE *argv, VALUE self) {
    TileMapSelectTool *arg1 = (TileMapSelectTool *) 0 ;
    SwigValueWrapper< CL_Rect > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileMapSelectTool, 1);
    result = ((TileMapSelectTool const *)arg1)->get_selection_rect();
    
    {
        CL_Rect * resultptr;
        resultptr = new CL_Rect((CL_Rect &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Rect, 1);
    }
    return vresult;
}


static VALUE
_wrap_TileMapSelectTool_to_tool(int argc, VALUE *argv, VALUE self) {
    TileMapSelectTool *arg1 = (TileMapSelectTool *) 0 ;
    Tool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_TileMapSelectTool, 1);
    result = (arg1)->to_tool();
    
    {
        Tool * resultptr;
        resultptr = new Tool((Tool &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Tool, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjMapSelectTool_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjMapSelectTool_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjMapSelectTool);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjMapSelectTool(int argc, VALUE *argv, VALUE self) {
    ObjMapSelectTool *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (ObjMapSelectTool *)new ObjMapSelectTool();
    DATA_PTR(self) = result;
    return self;
}


static void
free_ObjMapSelectTool(ObjMapSelectTool *arg1) {
    delete arg1;
}
static VALUE
_wrap_ObjMapSelectTool_clear_selection(int argc, VALUE *argv, VALUE self) {
    ObjMapSelectTool *arg1 = (ObjMapSelectTool *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSelectTool, 1);
    (arg1)->clear_selection();
    
    return Qnil;
}


static VALUE
_wrap_ObjMapSelectTool_get_selection(int argc, VALUE *argv, VALUE self) {
    ObjMapSelectTool *arg1 = (ObjMapSelectTool *) 0 ;
    ObjMapSelectTool::Selection result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSelectTool, 1);
    result = ((ObjMapSelectTool const *)arg1)->get_selection();
    
    {
        vresult = rb_ary_new2((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++) {
            ObjMapObject* x = new ObjMapObject(((ObjMapSelectTool::Selection &)result)[i]);
            rb_ary_store(vresult,i,
            SWIG_NewPointerObj((void *) x, 
            SWIGTYPE_p_ObjMapObject, 1));
        }
    }
    return vresult;
}


static VALUE
_wrap_ObjMapSelectTool_set_selection(int argc, VALUE *argv, VALUE self) {
    ObjMapSelectTool *arg1 = (ObjMapSelectTool *) 0 ;
    ObjMapSelectTool::Selection *arg2 = 0 ;
    std::vector<ObjMapObject > temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSelectTool, 1);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            temp2 = std::vector<ObjMapObject >(size);
            arg2 = &temp2;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                ObjMapObject* x;
                SWIG_ConvertPtr(o, (void **) &x, SWIGTYPE_p_ObjMapObject, 1);
                temp2[i] = *x;
            }
        } else {
            SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapSelectTool__Selection, 1);
        }
    }
    (arg1)->set_selection((ObjMapSelectTool::Selection const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjMapSelectTool_sig_on_popup_menu_display(int argc, VALUE *argv, VALUE self) {
    ObjMapSelectTool *arg1 = (ObjMapSelectTool *) 0 ;
    CL_Signal_v1<CL_Menu * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSelectTool, 1);
    {
        CL_Signal_v1<CL_Menu * > &_result_ref = (arg1)->sig_on_popup_menu_display();
        result = (CL_Signal_v1<CL_Menu * > *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v1TCL_Menu_p_t,0);
    return vresult;
}


static VALUE
_wrap_ObjMapSelectTool_to_tool(int argc, VALUE *argv, VALUE self) {
    ObjMapSelectTool *arg1 = (ObjMapSelectTool *) 0 ;
    Tool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSelectTool, 1);
    result = (arg1)->to_tool();
    
    {
        Tool * resultptr;
        resultptr = new Tool((Tool &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Tool, 1);
    }
    return vresult;
}


static VALUE
_wrap_new_ObjMapSpriteObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
    ObjMapSpriteObject *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (ObjMapSpriteObject *)new ObjMapSpriteObject();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjMapSpriteObject_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjMapSpriteObject_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjMapSpriteObject);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjMapSpriteObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CL_Sprite *arg1 = 0 ;
    CL_Point *arg2 = 0 ;
    MetaData *arg3 = 0 ;
    ObjMapSpriteObject *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Sprite, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_MetaData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjMapSpriteObject *)new ObjMapSpriteObject((CL_Sprite const &)*arg1,(CL_Point const &)*arg2,(MetaData const &)*arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_ObjMapSpriteObject(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_ObjMapSpriteObject__SWIG_0(nargs, args, self);
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_Sprite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CL_Point, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_MetaData, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_ObjMapSpriteObject__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_ObjMapSpriteObject'");
    return Qnil;
}


static VALUE
_wrap_ObjMapSpriteObject_flip_horizontal(int argc, VALUE *argv, VALUE self) {
    ObjMapSpriteObject *arg1 = (ObjMapSpriteObject *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSpriteObject, 1);
    (arg1)->flip_horizontal();
    
    return Qnil;
}


static VALUE
_wrap_ObjMapSpriteObject_flip_vertical(int argc, VALUE *argv, VALUE self) {
    ObjMapSpriteObject *arg1 = (ObjMapSpriteObject *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSpriteObject, 1);
    (arg1)->flip_vertical();
    
    return Qnil;
}


static VALUE
_wrap_ObjMapSpriteObject_to_object(int argc, VALUE *argv, VALUE self) {
    ObjMapSpriteObject *arg1 = (ObjMapSpriteObject *) 0 ;
    ObjMapObject result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapSpriteObject, 1);
    result = (arg1)->to_object();
    
    {
        ObjMapObject * resultptr;
        resultptr = new ObjMapObject((ObjMapObject &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ObjMapObject, 1);
    }
    return vresult;
}


static void
free_ObjMapSpriteObject(ObjMapSpriteObject *arg1) {
    delete arg1;
}
static VALUE
_wrap_new_ObjMapObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (ObjMapObject *)new ObjMapObject();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_ObjMapObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
    SharedPtr<ObjMapObjectImpl > *arg1 = 0 ;
    ObjMapObject *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_SharedPtrTObjMapObjectImpl_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjMapObject *)new ObjMapObject((SharedPtr<ObjMapObjectImpl > const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjMapObject_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjMapObject_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjMapObject);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjMapObject__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = 0 ;
    MetaData *arg2 = 0 ;
    ObjMapObject *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Point, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_MetaData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjMapObject *)new ObjMapObject((CL_Point const &)*arg1,(MetaData const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_ObjMapObject(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_ObjMapObject__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_SharedPtrTObjMapObjectImpl_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_ObjMapObject__SWIG_1(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CL_Point, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_MetaData, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_ObjMapObject__SWIG_2(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_ObjMapObject'");
    return Qnil;
}


static void
free_ObjMapObject(ObjMapObject *arg1) {
    delete arg1;
}
static VALUE
_wrap_ObjMapObject_get_pos(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    SwigValueWrapper< CL_Point > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    result = ((ObjMapObject const *)arg1)->get_pos();
    
    {
        CL_Point * resultptr;
        resultptr = new CL_Point((CL_Point &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Point, 1);
    }
    return vresult;
}


static VALUE
_wrap_ObjMapObject_set_pos(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    CL_Point *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_pos((CL_Point const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjMapObject_get_metadata(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    MetaData result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    result = ((ObjMapObject const *)arg1)->get_metadata();
    
    {
        MetaData * resultptr;
        resultptr = new MetaData((MetaData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_MetaData, 1);
    }
    return vresult;
}


static VALUE
_wrap_ObjMapObject_set_metadata(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    MetaData arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    {
        MetaData * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_MetaData, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->set_metadata(arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjMapObject_sig_move(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    CL_Signal_v1<ObjMapObject > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    {
        CL_Signal_v1<ObjMapObject > &_result_ref = (arg1)->sig_move();
        result = (CL_Signal_v1<ObjMapObject > *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_CL_Signal_v1TObjMapObject_t,0);
    return vresult;
}


static VALUE
_wrap_ObjMapObject_draw(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    (arg1)->draw();
    
    return Qnil;
}


static VALUE
_wrap_ObjMapObject_get_bound_rect(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    SwigValueWrapper< CL_Rect > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    result = ((ObjMapObject const *)arg1)->get_bound_rect();
    
    {
        CL_Rect * resultptr;
        resultptr = new CL_Rect((CL_Rect &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Rect, 1);
    }
    return vresult;
}


static VALUE
_wrap_ObjMapObject_is_null(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    result = (bool)((ObjMapObject const *)arg1)->is_null();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_ObjMapObject___eq__(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    ObjMapObject *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((ObjMapObject const *)arg1)->operator ==((ObjMapObject const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_ObjMapObject___lt__(int argc, VALUE *argv, VALUE self) {
    ObjMapObject *arg1 = (ObjMapObject *) 0 ;
    ObjMapObject *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapObject, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ObjMapObject, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((ObjMapObject const *)arg1)->operator <((ObjMapObject const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ZoomTool_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ZoomTool_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ZoomTool);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ZoomTool(int argc, VALUE *argv, VALUE self) {
    ZoomTool *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (ZoomTool *)new ZoomTool();
    DATA_PTR(self) = result;
    return self;
}


static void
free_ZoomTool(ZoomTool *arg1) {
    delete arg1;
}
static VALUE
_wrap_ZoomTool_to_tool(int argc, VALUE *argv, VALUE self) {
    ZoomTool *arg1 = (ZoomTool *) 0 ;
    Tool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ZoomTool, 1);
    result = (arg1)->to_tool();
    
    {
        Tool * resultptr;
        resultptr = new Tool((Tool &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Tool, 1);
    }
    return vresult;
}


static VALUE
_wrap_new_GraphicContextState__SWIG_0(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (GraphicContextState *)new GraphicContextState();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_GraphicContextState_allocate(VALUE self) {
#else
    static VALUE
    _wrap_GraphicContextState_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_GraphicContextState);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_GraphicContextState__SWIG_1(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    int arg2 ;
    GraphicContextState *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2INT(argv[0]);
    arg2 = NUM2INT(argv[1]);
    result = (GraphicContextState *)new GraphicContextState(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_GraphicContextState(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_GraphicContextState__SWIG_0(nargs, args, self);
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_GraphicContextState__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_GraphicContextState'");
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_set_size(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    int arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    (arg1)->set_size(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_push(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    (arg1)->push();
    
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_pop(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    (arg1)->pop();
    
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_get_clip_rect(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    SwigValueWrapper< CL_Rect > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    result = (arg1)->get_clip_rect();
    
    {
        CL_Rect * resultptr;
        resultptr = new CL_Rect((CL_Rect &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Rect, 1);
    }
    return vresult;
}


static VALUE
_wrap_GraphicContextState_get_width(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    result = (int)((GraphicContextState const *)arg1)->get_width();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_GraphicContextState_get_height(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    result = (int)((GraphicContextState const *)arg1)->get_height();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_GraphicContextState_set_pos(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    CL_Pointf *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Pointf, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_pos((CL_Pointf const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_get_pos(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    CL_Pointf result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    result = ((GraphicContextState const *)arg1)->get_pos();
    
    {
        CL_Pointf * resultptr;
        resultptr = new CL_Pointf((CL_Pointf &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Pointf, 1);
    }
    return vresult;
}


static VALUE
_wrap_GraphicContextState_set_zoom__SWIG_0(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    CL_Pointf arg2 ;
    float arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    {
        CL_Pointf * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_CL_Pointf, 1);
        if (ptr) arg2 = *ptr;
    }
    arg3 = (float) NUM2DBL(argv[1]);
    (arg1)->set_zoom(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_set_zoom__SWIG_1(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    (arg1)->set_zoom(arg2);
    
    return Qnil;
}


static VALUE _wrap_GraphicContextState_set_zoom(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_GraphicContextState, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FLOAT) || (TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_GraphicContextState_set_zoom__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_GraphicContextState, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CL_Pointf, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_GraphicContextState_set_zoom__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'GraphicContextState_set_zoom'");
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_get_zoom(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    float result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    result = (float)(arg1)->get_zoom();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_GraphicContextState_zoom_to(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    CL_Rect *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Rect, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->zoom_to((CL_Rect const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_GraphicContextState_screen2world(int argc, VALUE *argv, VALUE self) {
    GraphicContextState *arg1 = (GraphicContextState *) 0 ;
    CL_Point *arg2 = 0 ;
    CL_Pointf result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GraphicContextState, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CL_Point, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->screen2world((CL_Point const &)*arg2);
    
    {
        CL_Pointf * resultptr;
        resultptr = new CL_Pointf((CL_Pointf &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Pointf, 1);
    }
    return vresult;
}


static void
free_GraphicContextState(GraphicContextState *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_ObjMapPathNode_allocate(VALUE self) {
#else
    static VALUE
    _wrap_ObjMapPathNode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_ObjMapPathNode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_ObjMapPathNode(int argc, VALUE *argv, VALUE self) {
    CL_Point *arg1 = 0 ;
    MetaData *arg2 = 0 ;
    ObjMapPathNode *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Point, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_MetaData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (ObjMapPathNode *)new ObjMapPathNode((CL_Point const &)*arg1,(MetaData const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_ObjMapPathNode_connect(int argc, VALUE *argv, VALUE self) {
    ObjMapPathNode *arg1 = (ObjMapPathNode *) 0 ;
    SwigValueWrapper< ObjMapPathNode > arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapPathNode, 1);
    {
        ObjMapPathNode * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ObjMapPathNode, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->connect(arg2);
    
    return Qnil;
}


static VALUE
_wrap_ObjMapPathNode_disconnect(int argc, VALUE *argv, VALUE self) {
    ObjMapPathNode *arg1 = (ObjMapPathNode *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapPathNode, 1);
    (arg1)->disconnect();
    
    return Qnil;
}


static VALUE
_wrap_ObjMapPathNode_to_object(int argc, VALUE *argv, VALUE self) {
    ObjMapPathNode *arg1 = (ObjMapPathNode *) 0 ;
    ObjMapObject result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_ObjMapPathNode, 1);
    result = (arg1)->to_object();
    
    {
        ObjMapObject * resultptr;
        resultptr = new ObjMapObject((ObjMapObject &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ObjMapObject, 1);
    }
    return vresult;
}


static void
free_ObjMapPathNode(ObjMapPathNode *arg1) {
    delete arg1;
}
static VALUE
_wrap_load_netpanzer_tiles(int argc, VALUE *argv, VALUE self) {
    Tileset arg1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        Tileset * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Tileset, 1);
        if (ptr) arg1 = *ptr;
    }
    load_netpanzer_tiles(arg1);
    
    return Qnil;
}


static VALUE
_wrap_new_NetPanzerFileStruct__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Tileset arg1 ;
    int arg2 ;
    int arg3 ;
    NetPanzerFileStruct *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    {
        Tileset * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Tileset, 1);
        if (ptr) arg1 = *ptr;
    }
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    result = (NetPanzerFileStruct *)new NetPanzerFileStruct(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_NetPanzerFileStruct_allocate(VALUE self) {
#else
    static VALUE
    _wrap_NetPanzerFileStruct_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_NetPanzerFileStruct);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_NetPanzerFileStruct__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Tileset arg1 ;
    std::string *arg2 = 0 ;
    NetPanzerFileStruct *result;
    std::string temp2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        Tileset * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Tileset, 1);
        if (ptr) arg1 = *ptr;
    }
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[1]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    result = (NetPanzerFileStruct *)new NetPanzerFileStruct(arg1,(std::string const &)*arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_NetPanzerFileStruct(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Tileset, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = (TYPE(argv[1]) == T_STRING) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_NetPanzerFileStruct__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Tileset, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_NetPanzerFileStruct__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetPanzerFileStruct'");
    return Qnil;
}


static VALUE
_wrap_NetPanzerFileStruct_get_id_header(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    result = (arg1)->get_id_header();
    
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_NetPanzerFileStruct_get_name(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    result = (arg1)->get_name();
    
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_NetPanzerFileStruct_get_description(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    result = (arg1)->get_description();
    
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_NetPanzerFileStruct_get_tilemap(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    TilemapLayer result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    result = (arg1)->get_tilemap();
    
    {
        TilemapLayer * resultptr;
        resultptr = new TilemapLayer((TilemapLayer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_TilemapLayer, 1);
    }
    return vresult;
}


static VALUE
_wrap_NetPanzerFileStruct_set_id_header(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    (arg1)->set_id_header((std::string const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_NetPanzerFileStruct_set_name(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    (arg1)->set_name((std::string const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_NetPanzerFileStruct_set_description(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    (arg1)->set_description((std::string const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_NetPanzerFileStruct_set_tilemap(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    TilemapLayer arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    {
        TilemapLayer * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_TilemapLayer, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->set_tilemap(arg2);
    
    return Qnil;
}


static VALUE
_wrap_NetPanzerFileStruct_save(int argc, VALUE *argv, VALUE self) {
    NetPanzerFileStruct *arg1 = (NetPanzerFileStruct *) 0 ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_NetPanzerFileStruct, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[0]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    (arg1)->save((std::string const &)*arg2);
    
    return Qnil;
}


static void
free_NetPanzerFileStruct(NetPanzerFileStruct *arg1) {
    delete arg1;
}
static VALUE
_wrap_make_sprite(int argc, VALUE *argv, VALUE self) {
    std::string *arg1 = 0 ;
    CL_Sprite result;
    std::string temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp1 = std::string(StringValuePtr(argv[0]));
            arg1 = &temp1;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    result = make_sprite((std::string const &)*arg1);
    
    {
        CL_Sprite * resultptr;
        resultptr = new CL_Sprite((CL_Sprite &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Sprite, 1);
    }
    return vresult;
}


static VALUE
_wrap_make_pixelbuffer(int argc, VALUE *argv, VALUE self) {
    std::string *arg1 = 0 ;
    CL_PixelBuffer result;
    std::string temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp1 = std::string(StringValuePtr(argv[0]));
            arg1 = &temp1;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    result = make_pixelbuffer((std::string const &)*arg1);
    
    {
        CL_PixelBuffer * resultptr;
        resultptr = new CL_PixelBuffer((CL_PixelBuffer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_PixelBuffer, 1);
    }
    return vresult;
}


static VALUE
_wrap_make_region_pixelbuffer(int argc, VALUE *argv, VALUE self) {
    std::string *arg1 = 0 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    CL_PixelBuffer result;
    std::string temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 5) || (argc > 5))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp1 = std::string(StringValuePtr(argv[0]));
            arg1 = &temp1;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    arg4 = NUM2INT(argv[3]);
    arg5 = NUM2INT(argv[4]);
    result = make_region_pixelbuffer((std::string const &)*arg1,arg2,arg3,arg4,arg5);
    
    {
        CL_PixelBuffer * resultptr;
        resultptr = new CL_PixelBuffer((CL_PixelBuffer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_PixelBuffer, 1);
    }
    return vresult;
}


static VALUE
_wrap_make_sprite_from_resource(int argc, VALUE *argv, VALUE self) {
    std::string *arg1 = 0 ;
    CL_ResourceManager *arg2 = 0 ;
    CL_Sprite result;
    std::string temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp1 = std::string(StringValuePtr(argv[0]));
            arg1 = &temp1;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_ResourceManager, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = make_sprite_from_resource((std::string const &)*arg1,*arg2);
    
    {
        CL_Sprite * resultptr;
        resultptr = new CL_Sprite((CL_Sprite &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_Sprite, 1);
    }
    return vresult;
}


static VALUE
_wrap_make_pixelbuffer_from_resource(int argc, VALUE *argv, VALUE self) {
    std::string *arg1 = 0 ;
    CL_ResourceManager *arg2 = 0 ;
    CL_PixelBuffer result;
    std::string temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    {
        if (TYPE(argv[0]) == T_STRING) {
            temp1 = std::string(StringValuePtr(argv[0]));
            arg1 = &temp1;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_CL_ResourceManager, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = make_pixelbuffer_from_resource((std::string const &)*arg1,*arg2);
    
    {
        CL_PixelBuffer * resultptr;
        resultptr = new CL_PixelBuffer((CL_PixelBuffer &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_CL_PixelBuffer, 1);
    }
    return vresult;
}


static VALUE
_wrap_make_metadata(int argc, VALUE *argv, VALUE self) {
    VALUE arg1 ;
    MetaData result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = argv[0];
    result = make_metadata(arg1);
    
    {
        MetaData * resultptr;
        resultptr = new MetaData((MetaData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_MetaData, 1);
    }
    return vresult;
}


static VALUE
_wrap_get_ruby_object(int argc, VALUE *argv, VALUE self) {
    MetaData *arg1 = 0 ;
    VALUE result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_MetaData, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (VALUE)get_ruby_object((MetaData const &)*arg1);
    
    vresult = result;
    return vresult;
}


static VALUE
_wrap_connect(int argc, VALUE *argv, VALUE self) {
    CL_Signal_v0 *arg1 = 0 ;
    VALUE arg2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Signal_v0, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg2 = argv[1];
    connect(*arg1,arg2);
    
    return Qnil;
}


static VALUE
_wrap_connect_v1(int argc, VALUE *argv, VALUE self) {
    CL_Signal_v1<int > *arg1 = 0 ;
    VALUE arg2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Signal_v1Tint_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg2 = argv[1];
    connect_v1(*arg1,arg2);
    
    return Qnil;
}


static VALUE
_wrap_connect_v2(int argc, VALUE *argv, VALUE self) {
    CL_Signal_v2<int,int > *arg1 = 0 ;
    VALUE arg2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Signal_v2Tint_int_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg2 = argv[1];
    connect_v2(*arg1,arg2);
    
    return Qnil;
}


static VALUE
_wrap_connect_v1_ObjMapObject(int argc, VALUE *argv, VALUE self) {
    CL_Signal_v1<ObjMapObject > *arg1 = 0 ;
    VALUE arg2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CL_Signal_v1TObjMapObject_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg2 = argv[1];
    connect_v1_ObjMapObject(*arg1,arg2);
    
    return Qnil;
}


static VALUE
_wrap_sexpr_read_from_file(int argc, VALUE *argv, VALUE self) {
    char *arg1 ;
    VALUE result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = StringValuePtr(argv[0]);
    result = (VALUE)sexpr_read_from_file((char const *)arg1);
    
    vresult = result;
    return vresult;
}



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

static void *_p_CL_ListBoxTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((CL_ListBox *) x));
}
static void *_p_CL_WindowTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((CL_Window *) x));
}
static void *_p_PanelTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Panel *) x));
}
static void *_p_MinimapTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Minimap *) x));
}
static void *_p_CL_LabelTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((CL_Label *) x));
}
static void *_p_CL_MenuTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((CL_Menu *) x));
}
static void *_p_CL_ButtonTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((CL_Button *) x));
}
static void *_p_WindowTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Window *) x));
}
static void *_p_EditorMapComponentTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((EditorMapComponent *) x));
}
static void *_p_IconTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Icon *) x));
}
static void *_p_CL_MenuNodeTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((CL_MenuNode *) x));
}
static void *_p_DirectoryViewTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((DirectoryView *) x));
}
static void *_p_MenubarTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Menubar *) x));
}
static void *_p_MenuTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Menu *) x));
}
static void *_p_ConsoleTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Console *) x));
}
static void *_p_CL_InputBoxTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((CL_InputBox *) x));
}
static void *_p_ScrollbarTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((Scrollbar *) x));
}
static void *_p_ObjectSelectorTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((ObjectSelector *) x));
}
static void *_p_TileSelectorTo_p_CL_Component(void *x) {
    return (void *)((CL_Component *)  ((TileSelector *) x));
}
static swig_type_info _swigt__p_Icon[] = {{"_p_Icon", 0, "Icon *", 0},{"_p_Icon"},{0}};
static swig_type_info _swigt__p_Tileset[] = {{"_p_Tileset", 0, "Tileset *", 0},{"_p_Tileset"},{0}};
static swig_type_info _swigt__p_CL_Color[] = {{"_p_CL_Color", 0, "CL_Color *", 0},{"_p_CL_Color"},{0}};
static swig_type_info _swigt__p_CL_Size[] = {{"_p_CL_Size", 0, "CL_Size *", 0},{"_p_CL_Size"},{0}};
static swig_type_info _swigt__p_Tile[] = {{"_p_Tile", 0, "Tile *", 0},{"_p_Tile"},{0}};
static swig_type_info _swigt__p_ZoomTool[] = {{"_p_ZoomTool", 0, "ZoomTool *", 0},{"_p_ZoomTool"},{0}};
static swig_type_info _swigt__p_CL_Pointf[] = {{"_p_CL_Pointf", 0, "CL_Pointf *", 0},{"_p_CL_Pointf"},{0}};
static swig_type_info _swigt__p_CL_MenuNode[] = {{"_p_CL_MenuNode", 0, "CL_MenuNode *", 0},{"_p_CL_MenuNode"},{0}};
static swig_type_info _swigt__p_CL_PixelBuffer[] = {{"_p_CL_PixelBuffer", 0, "CL_PixelBuffer *", 0},{"_p_CL_PixelBuffer"},{0}};
static swig_type_info _swigt__p_Tool[] = {{"_p_Tool", 0, "Tool *", 0},{"_p_Tool"},{0}};
static swig_type_info _swigt__p_ObjMapSelectTool[] = {{"_p_ObjMapSelectTool", 0, "ObjMapSelectTool *", 0},{"_p_ObjMapSelectTool"},{0}};
static swig_type_info _swigt__p_TileMapSelectTool[] = {{"_p_TileMapSelectTool", 0, "TileMapSelectTool *", 0},{"_p_TileMapSelectTool"},{0}};
static swig_type_info _swigt__p_CL_SlotContainer[] = {{"_p_CL_SlotContainer", 0, "CL_SlotContainer *", 0},{"_p_CL_SlotContainer"},{0}};
static swig_type_info _swigt__p_CL_Button[] = {{"_p_CL_Button", 0, "CL_Button *", 0},{"_p_CL_Button"},{0}};
static swig_type_info _swigt__p_Console[] = {{"_p_Console", 0, "Console *", 0},{"_p_Console"},{0}};
static swig_type_info _swigt__p_CL_Point[] = {{"_p_CL_Point", 0, "CL_Point *", 0},{"_p_CL_Point"},{0}};
static swig_type_info _swigt__p_TileMapPaintTool[] = {{"_p_TileMapPaintTool", 0, "TileMapPaintTool *", 0},{"_p_TileMapPaintTool"},{0}};
static swig_type_info _swigt__p_Minimap[] = {{"_p_Minimap", 0, "Minimap *", 0},{"_p_Minimap"},{0}};
static swig_type_info _swigt__p_CL_Rect[] = {{"_p_CL_Rect", 0, "CL_Rect *", 0},{"_p_CL_Rect"},{0}};
static swig_type_info _swigt__p_DirectoryView[] = {{"_p_DirectoryView", 0, "DirectoryView *", 0},{"_p_DirectoryView"},{0}};
static swig_type_info _swigt__p_CL_InputBox[] = {{"_p_CL_InputBox", 0, "CL_InputBox *", 0},{"_p_CL_InputBox"},{0}};
static swig_type_info _swigt__p_TileBrush[] = {{"_p_TileBrush", 0, "TileBrush *", 0},{"_p_TileBrush"},{0}};
static swig_type_info _swigt__p_ObjectBrush[] = {{"_p_ObjectBrush", 0, "ObjectBrush *", 0},{"_p_ObjectBrush"},{0}};
static swig_type_info _swigt__p_CL_Label[] = {{"_p_CL_Label", 0, "CL_Label *", 0},{"_p_CL_Label"},{0}};
static swig_type_info _swigt__p_Panel[] = {{"_p_Panel", 0, "Panel *", 0},{"_p_Panel"},{0}};
static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0},{"_p_int"},{0}};
static swig_type_info _swigt__p_CL_Signal_v1Tint_t[] = {{"_p_CL_Signal_v1Tint_t", 0, "CL_Signal_v1<int > *", 0},{"_p_CL_Signal_v1Tint_t"},{0}};
static swig_type_info _swigt__p_Scrollbar[] = {{"_p_Scrollbar", 0, "Scrollbar *", 0},{"_p_Scrollbar"},{0}};
static swig_type_info _swigt__p_ObjMapSpriteObject[] = {{"_p_ObjMapSpriteObject", 0, "ObjMapSpriteObject *", 0},{"_p_ObjMapSpriteObject"},{0}};
static swig_type_info _swigt__p_CL_Sprite[] = {{"_p_CL_Sprite", 0, "CL_Sprite *", 0},{"_p_CL_Sprite"},{0}};
static swig_type_info _swigt__p_Workspace[] = {{"_p_Workspace", 0, "Workspace *", 0},{"_p_Workspace"},{0}};
static swig_type_info _swigt__p_ObjectLayer[] = {{"_p_ObjectLayer", 0, "ObjectLayer *", 0},{"_p_ObjectLayer"},{0}};
static swig_type_info _swigt__p_Window[] = {{"_p_Window", 0, "Window *", 0},{"_p_Window"},{0}};
static swig_type_info _swigt__p_CL_Window[] = {{"_p_CL_Window", 0, "CL_Window *", 0},{"_p_CL_Window"},{0}};
static swig_type_info _swigt__p_EditorMapComponent[] = {{"_p_EditorMapComponent", 0, "EditorMapComponent *", 0},{"_p_EditorMapComponent"},{0}};
static swig_type_info _swigt__p_CL_Component[] = {{"_p_CL_Component", 0, "CL_Component *", 0},{"_p_CL_ListBox", _p_CL_ListBoxTo_p_CL_Component},{"_p_CL_Window", _p_CL_WindowTo_p_CL_Component},{"_p_Window", _p_WindowTo_p_CL_Component},{"_p_Minimap", _p_MinimapTo_p_CL_Component},{"_p_CL_Label", _p_CL_LabelTo_p_CL_Component},{"_p_CL_Menu", _p_CL_MenuTo_p_CL_Component},{"_p_CL_Button", _p_CL_ButtonTo_p_CL_Component},{"_p_EditorMapComponent", _p_EditorMapComponentTo_p_CL_Component},{"_p_CL_Component"},{"_p_CL_MenuNode", _p_CL_MenuNodeTo_p_CL_Component},{"_p_DirectoryView", _p_DirectoryViewTo_p_CL_Component},{"_p_Menubar", _p_MenubarTo_p_CL_Component},{"_p_Console", _p_ConsoleTo_p_CL_Component},{"_p_Icon", _p_IconTo_p_CL_Component},{"_p_Panel", _p_PanelTo_p_CL_Component},{"_p_CL_InputBox", _p_CL_InputBoxTo_p_CL_Component},{"_p_Scrollbar", _p_ScrollbarTo_p_CL_Component},{"_p_Menu", _p_MenuTo_p_CL_Component},{"_p_ObjectSelector", _p_ObjectSelectorTo_p_CL_Component},{"_p_TileSelector", _p_TileSelectorTo_p_CL_Component},{0}};
static swig_type_info _swigt__p_ObjMapPathNode[] = {{"_p_ObjMapPathNode", 0, "ObjMapPathNode *", 0},{"_p_ObjMapPathNode"},{0}};
static swig_type_info _swigt__p_Layer[] = {{"_p_Layer", 0, "Layer *", 0},{"_p_Layer"},{0}};
static swig_type_info _swigt__p_ObjMapSelectTool__Selection[] = {{"_p_ObjMapSelectTool__Selection", 0, "ObjMapSelectTool::Selection const *", 0},{"_p_ObjMapSelectTool__Selection"},{"_p_std__vectorTObjMapObject_t"},{0}};
static swig_type_info _swigt__p_CL_InputEvent[] = {{"_p_CL_InputEvent", 0, "CL_InputEvent *", 0},{"_p_CL_InputEvent"},{0}};
static swig_type_info _swigt__p_CL_ListBox[] = {{"_p_CL_ListBox", 0, "CL_ListBox *", 0},{"_p_CL_ListBox"},{0}};
static swig_type_info _swigt__p_Menubar[] = {{"_p_Menubar", 0, "Menubar *", 0},{"_p_Menubar"},{0}};
static swig_type_info _swigt__p_TileSelector__Tiles[] = {{"_p_TileSelector__Tiles", 0, "TileSelector::Tiles const *", 0},{"_p_std__vectorTint_t"},{"_p_TileSelector__Tiles"},{0}};
static swig_type_info _swigt__p_CL_Signal_v1Tstd__string_t[] = {{"_p_CL_Signal_v1Tstd__string_t", 0, "CL_Signal_v1<std::string > *", 0},{"_p_CL_Signal_v1Tstd__string_t"},{0}};
static swig_type_info _swigt__p_std__listTstd__string_t[] = {{"_p_std__listTstd__string_t", 0, "std::list<std::string > *", 0},{"_p_std__listTstd__string_t"},{0}};
static swig_type_info _swigt__p_CL_Signal_v1TCL_Menu_p_t[] = {{"_p_CL_Signal_v1TCL_Menu_p_t", 0, "CL_Signal_v1<CL_Menu * > *", 0},{"_p_CL_Signal_v1TCL_Menu_p_t"},{0}};
static swig_type_info _swigt__p_SharedPtrTMetaDataImpl_t[] = {{"_p_SharedPtrTMetaDataImpl_t", 0, "SharedPtr<MetaDataImpl > *", 0},{"_p_SharedPtrTMetaDataImpl_t"},{0}};
static swig_type_info _swigt__p_GraphicContextState[] = {{"_p_GraphicContextState", 0, "GraphicContextState *", 0},{"_p_GraphicContextState"},{0}};
static swig_type_info _swigt__p_CL_Signal_v0[] = {{"_p_CL_Signal_v0", 0, "CL_Signal_v0 *", 0},{"_p_CL_Signal_v0"},{0}};
static swig_type_info _swigt__p_Editor[] = {{"_p_Editor", 0, "Editor *", 0},{"_p_Editor"},{0}};
static swig_type_info _swigt__p_CL_Signal_v1Tfloat_t[] = {{"_p_CL_Signal_v1Tfloat_t", 0, "CL_Signal_v1<float > *", 0},{"_p_CL_Signal_v1Tfloat_t"},{0}};
static swig_type_info _swigt__p_NetPanzerFileStruct[] = {{"_p_NetPanzerFileStruct", 0, "NetPanzerFileStruct *", 0},{"_p_NetPanzerFileStruct"},{0}};
static swig_type_info _swigt__p_GUIManager[] = {{"_p_GUIManager", 0, "GUIManager *", 0},{"_p_GUIManager"},{0}};
static swig_type_info _swigt__p_CL_StyleManager[] = {{"_p_CL_StyleManager", 0, "CL_StyleManager *", 0},{"_p_CL_StyleManager"},{0}};
static swig_type_info _swigt__p_CL_ResourceManager[] = {{"_p_CL_ResourceManager", 0, "CL_ResourceManager *", 0},{"_p_CL_ResourceManager"},{0}};
static swig_type_info _swigt__p_CL_InputSourceProvider[] = {{"_p_CL_InputSourceProvider", 0, "CL_InputSourceProvider *", 0},{"_p_CL_InputSourceProvider"},{0}};
static swig_type_info _swigt__p_std__vectorTint_t[] = {{"_p_std__vectorTint_t", 0, "std::vector<int > *", 0},{"_p_std__vectorTint_t"},{"_p_TileSelector__Tiles"},{0}};
static swig_type_info _swigt__p_FieldTint_t[] = {{"_p_FieldTint_t", 0, "Field<int > *", 0},{"_p_FieldTint_t"},{0}};
static swig_type_info _swigt__p_ObjMapObject[] = {{"_p_ObjMapObject", 0, "ObjMapObject *", 0},{"_p_ObjMapObject"},{0}};
static swig_type_info _swigt__p_Menu[] = {{"_p_Menu", 0, "Menu *", 0},{"_p_Menu"},{0}};
static swig_type_info _swigt__p_Command[] = {{"_p_Command", 0, "Command *", 0},{"_p_Command"},{0}};
static swig_type_info _swigt__p_PaintCommand[] = {{"_p_PaintCommand", 0, "PaintCommand *", 0},{"_p_PaintCommand"},{0}};
static swig_type_info _swigt__p_ObjectMoveCommand[] = {{"_p_ObjectMoveCommand", 0, "ObjectMoveCommand *", 0},{"_p_ObjectMoveCommand"},{0}};
static swig_type_info _swigt__p_ObjectAddCommand[] = {{"_p_ObjectAddCommand", 0, "ObjectAddCommand *", 0},{"_p_ObjectAddCommand"},{0}};
static swig_type_info _swigt__p_ObjectDeleteCommand[] = {{"_p_ObjectDeleteCommand", 0, "ObjectDeleteCommand *", 0},{"_p_ObjectDeleteCommand"},{0}};
static swig_type_info _swigt__p_EditorMap[] = {{"_p_EditorMap", 0, "EditorMap *", 0},{"_p_EditorMap"},{0}};
static swig_type_info _swigt__p_Flexlay[] = {{"_p_Flexlay", 0, "Flexlay *", 0},{"_p_Flexlay"},{0}};
static swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{0}};
static swig_type_info _swigt__p_CL_Signal_v2Tint_int_t[] = {{"_p_CL_Signal_v2Tint_int_t", 0, "CL_Signal_v2<int,int > *", 0},{"_p_CL_Signal_v2Tint_int_t"},{0}};
static swig_type_info _swigt__p_CL_Menu[] = {{"_p_CL_Menu", 0, "CL_Menu *", 0},{"_p_CL_Menu"},{0}};
static swig_type_info _swigt__p_MetaData[] = {{"_p_MetaData", 0, "MetaData *", 0},{"_p_MetaData"},{0}};
static swig_type_info _swigt__p_CL_Signal_v1TObjMapObject_t[] = {{"_p_CL_Signal_v1TObjMapObject_t", 0, "CL_Signal_v1<ObjMapObject > *", 0},{"_p_CL_Signal_v1TObjMapObject_t"},{0}};
static swig_type_info _swigt__p_std__vectorTObjMapObject_t[] = {{"_p_std__vectorTObjMapObject_t", 0, "std::vector<ObjMapObject > *", 0},{"_p_std__vectorTObjMapObject_t"},{"_p_ObjMapSelectTool__Selection"},{0}};
static swig_type_info _swigt__p_TilemapLayer[] = {{"_p_TilemapLayer", 0, "TilemapLayer *", 0},{"_p_TilemapLayer"},{0}};
static swig_type_info _swigt__p_ObjectSelector[] = {{"_p_ObjectSelector", 0, "ObjectSelector *", 0},{"_p_ObjectSelector"},{0}};
static swig_type_info _swigt__p_TileSelector[] = {{"_p_TileSelector", 0, "TileSelector *", 0},{"_p_TileSelector"},{0}};
static swig_type_info _swigt__p_SharedPtrTLayerImpl_t[] = {{"_p_SharedPtrTLayerImpl_t", 0, "SharedPtr<LayerImpl > *", 0},{"_p_SharedPtrTLayerImpl_t"},{0}};
static swig_type_info _swigt__p_SharedPtrTCommandImpl_t[] = {{"_p_SharedPtrTCommandImpl_t", 0, "SharedPtr<CommandImpl > *", 0},{"_p_SharedPtrTCommandImpl_t"},{0}};
static swig_type_info _swigt__p_SharedPtrTObjMapObjectImpl_t[] = {{"_p_SharedPtrTObjMapObjectImpl_t", 0, "SharedPtr<ObjMapObjectImpl > *", 0},{"_p_SharedPtrTObjMapObjectImpl_t"},{0}};

static swig_type_info *swig_types_initial[] = {
_swigt__p_Icon, 
_swigt__p_Tileset, 
_swigt__p_CL_Color, 
_swigt__p_CL_Size, 
_swigt__p_Tile, 
_swigt__p_ZoomTool, 
_swigt__p_CL_Pointf, 
_swigt__p_CL_MenuNode, 
_swigt__p_CL_PixelBuffer, 
_swigt__p_Tool, 
_swigt__p_ObjMapSelectTool, 
_swigt__p_TileMapSelectTool, 
_swigt__p_CL_SlotContainer, 
_swigt__p_CL_Button, 
_swigt__p_Console, 
_swigt__p_CL_Point, 
_swigt__p_TileMapPaintTool, 
_swigt__p_Minimap, 
_swigt__p_CL_Rect, 
_swigt__p_DirectoryView, 
_swigt__p_CL_InputBox, 
_swigt__p_TileBrush, 
_swigt__p_ObjectBrush, 
_swigt__p_CL_Label, 
_swigt__p_Panel, 
_swigt__p_int, 
_swigt__p_CL_Signal_v1Tint_t, 
_swigt__p_Scrollbar, 
_swigt__p_ObjMapSpriteObject, 
_swigt__p_CL_Sprite, 
_swigt__p_Workspace, 
_swigt__p_ObjectLayer, 
_swigt__p_Window, 
_swigt__p_CL_Window, 
_swigt__p_EditorMapComponent, 
_swigt__p_CL_Component, 
_swigt__p_ObjMapPathNode, 
_swigt__p_Layer, 
_swigt__p_ObjMapSelectTool__Selection, 
_swigt__p_CL_InputEvent, 
_swigt__p_CL_ListBox, 
_swigt__p_Menubar, 
_swigt__p_TileSelector__Tiles, 
_swigt__p_CL_Signal_v1Tstd__string_t, 
_swigt__p_std__listTstd__string_t, 
_swigt__p_CL_Signal_v1TCL_Menu_p_t, 
_swigt__p_SharedPtrTMetaDataImpl_t, 
_swigt__p_GraphicContextState, 
_swigt__p_CL_Signal_v0, 
_swigt__p_Editor, 
_swigt__p_CL_Signal_v1Tfloat_t, 
_swigt__p_NetPanzerFileStruct, 
_swigt__p_GUIManager, 
_swigt__p_CL_StyleManager, 
_swigt__p_CL_ResourceManager, 
_swigt__p_CL_InputSourceProvider, 
_swigt__p_std__vectorTint_t, 
_swigt__p_FieldTint_t, 
_swigt__p_ObjMapObject, 
_swigt__p_Menu, 
_swigt__p_Command, 
_swigt__p_PaintCommand, 
_swigt__p_ObjectMoveCommand, 
_swigt__p_ObjectAddCommand, 
_swigt__p_ObjectDeleteCommand, 
_swigt__p_EditorMap, 
_swigt__p_Flexlay, 
_swigt__p_std__string, 
_swigt__p_CL_Signal_v2Tint_int_t, 
_swigt__p_CL_Menu, 
_swigt__p_MetaData, 
_swigt__p_CL_Signal_v1TObjMapObject_t, 
_swigt__p_std__vectorTObjMapObject_t, 
_swigt__p_TilemapLayer, 
_swigt__p_ObjectSelector, 
_swigt__p_TileSelector, 
_swigt__p_SharedPtrTLayerImpl_t, 
_swigt__p_SharedPtrTCommandImpl_t, 
_swigt__p_SharedPtrTObjMapObjectImpl_t, 
0
};


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


#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void) Init_flexlay_wrap(void) {
    int i;
    
    SWIG_InitRuntime();
    mFlexlay_wrap = rb_define_module("Flexlay_wrap");
    
    for (i = 0; swig_types_initial[i]; i++) {
        swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
        SWIG_define_class(swig_types[i]);
    }
    
    
    cStd_vector_int.klass = rb_define_class_under(mFlexlay_wrap, "Std_vector_int", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_std__vectorTint_t, (void *) &cStd_vector_int);
    rb_include_module(cStd_vector_int.klass, rb_eval_string("Enumerable"));
    rb_define_alloc_func(cStd_vector_int.klass, _wrap_Std_vector_int_allocate);
    rb_define_method(cStd_vector_int.klass, "initialize", VALUEFUNC(_wrap_new_Std_vector_int), -1);
    rb_define_method(cStd_vector_int.klass, "length", VALUEFUNC(_wrap_Std_vector_int___len__), -1);
    rb_define_method(cStd_vector_int.klass, "empty?", VALUEFUNC(_wrap_Std_vector_int_emptyq___), -1);
    rb_define_method(cStd_vector_int.klass, "clear", VALUEFUNC(_wrap_Std_vector_int_clear), -1);
    rb_define_method(cStd_vector_int.klass, "push", VALUEFUNC(_wrap_Std_vector_int_push), -1);
    rb_define_method(cStd_vector_int.klass, "pop", VALUEFUNC(_wrap_Std_vector_int_pop), -1);
    rb_define_method(cStd_vector_int.klass, "[]", VALUEFUNC(_wrap_Std_vector_int___getitem__), -1);
    rb_define_method(cStd_vector_int.klass, "[]=", VALUEFUNC(_wrap_Std_vector_int___setitem__), -1);
    rb_define_method(cStd_vector_int.klass, "each", VALUEFUNC(_wrap_Std_vector_int_each), -1);
    cStd_vector_int.mark = 0;
    cStd_vector_int.destroy = (void (*)(void *)) free_std_vectorlint_g___;
    
    cStd_vector_ObjMapObject.klass = rb_define_class_under(mFlexlay_wrap, "Std_vector_ObjMapObject", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_std__vectorTObjMapObject_t, (void *) &cStd_vector_ObjMapObject);
    rb_include_module(cStd_vector_ObjMapObject.klass, rb_eval_string("Enumerable"));
    rb_define_alloc_func(cStd_vector_ObjMapObject.klass, _wrap_Std_vector_ObjMapObject_allocate);
    rb_define_method(cStd_vector_ObjMapObject.klass, "initialize", VALUEFUNC(_wrap_new_Std_vector_ObjMapObject), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "length", VALUEFUNC(_wrap_Std_vector_ObjMapObject___len__), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "empty?", VALUEFUNC(_wrap_Std_vector_ObjMapObject_emptyq___), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "clear", VALUEFUNC(_wrap_Std_vector_ObjMapObject_clear), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "push", VALUEFUNC(_wrap_Std_vector_ObjMapObject_push), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "pop", VALUEFUNC(_wrap_Std_vector_ObjMapObject_pop), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "[]", VALUEFUNC(_wrap_Std_vector_ObjMapObject___getitem__), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "[]=", VALUEFUNC(_wrap_Std_vector_ObjMapObject___setitem__), -1);
    rb_define_method(cStd_vector_ObjMapObject.klass, "each", VALUEFUNC(_wrap_Std_vector_ObjMapObject_each), -1);
    cStd_vector_ObjMapObject.mark = 0;
    cStd_vector_ObjMapObject.destroy = (void (*)(void *)) free_std_vectorlObjMapObject_g___;
    
    cCL_Component.klass = rb_define_class_under(mFlexlay_wrap, "CL_Component", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Component, (void *) &cCL_Component);
    rb_define_alloc_func(cCL_Component.klass, _wrap_CL_Component_allocate);
    rb_define_method(cCL_Component.klass, "initialize", VALUEFUNC(_wrap_new_CL_Component), -1);
    rb_define_method(cCL_Component.klass, "show", VALUEFUNC(_wrap_CL_Component_show), -1);
    rb_define_method(cCL_Component.klass, "is_visible", VALUEFUNC(_wrap_CL_Component_is_visible), -1);
    rb_define_method(cCL_Component.klass, "set_size", VALUEFUNC(_wrap_CL_Component_set_size), -1);
    rb_define_method(cCL_Component.klass, "set_position", VALUEFUNC(_wrap_CL_Component_set_position), -1);
    rb_define_method(cCL_Component.klass, "get_position", VALUEFUNC(_wrap_CL_Component_get_position), -1);
    cCL_Component.mark = 0;
    
    cCL_Size.klass = rb_define_class_under(mFlexlay_wrap, "CL_Size", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Size, (void *) &cCL_Size);
    rb_define_alloc_func(cCL_Size.klass, _wrap_CL_Size_allocate);
    rb_define_method(cCL_Size.klass, "initialize", VALUEFUNC(_wrap_new_CL_Size), -1);
    rb_define_method(cCL_Size.klass, "width=", VALUEFUNC(_wrap_CL_Size_width_set), -1);
    rb_define_method(cCL_Size.klass, "width", VALUEFUNC(_wrap_CL_Size_width_get), -1);
    rb_define_method(cCL_Size.klass, "height=", VALUEFUNC(_wrap_CL_Size_height_set), -1);
    rb_define_method(cCL_Size.klass, "height", VALUEFUNC(_wrap_CL_Size_height_get), -1);
    cCL_Size.mark = 0;
    cCL_Size.destroy = (void (*)(void *)) free_CL_Size;
    
    cCL_Point.klass = rb_define_class_under(mFlexlay_wrap, "CL_Point", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Point, (void *) &cCL_Point);
    rb_define_alloc_func(cCL_Point.klass, _wrap_CL_Point_allocate);
    rb_define_method(cCL_Point.klass, "initialize", VALUEFUNC(_wrap_new_CL_Point), -1);
    rb_define_method(cCL_Point.klass, "x=", VALUEFUNC(_wrap_CL_Point_x_set), -1);
    rb_define_method(cCL_Point.klass, "x", VALUEFUNC(_wrap_CL_Point_x_get), -1);
    rb_define_method(cCL_Point.klass, "y=", VALUEFUNC(_wrap_CL_Point_y_set), -1);
    rb_define_method(cCL_Point.klass, "y", VALUEFUNC(_wrap_CL_Point_y_get), -1);
    cCL_Point.mark = 0;
    cCL_Point.destroy = (void (*)(void *)) free_CL_Point;
    
    cCL_Rect.klass = rb_define_class_under(mFlexlay_wrap, "CL_Rect", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Rect, (void *) &cCL_Rect);
    rb_define_alloc_func(cCL_Rect.klass, _wrap_CL_Rect_allocate);
    rb_define_method(cCL_Rect.klass, "initialize", VALUEFUNC(_wrap_new_CL_Rect), -1);
    rb_define_method(cCL_Rect.klass, "left=", VALUEFUNC(_wrap_CL_Rect_left_set), -1);
    rb_define_method(cCL_Rect.klass, "left", VALUEFUNC(_wrap_CL_Rect_left_get), -1);
    rb_define_method(cCL_Rect.klass, "right=", VALUEFUNC(_wrap_CL_Rect_right_set), -1);
    rb_define_method(cCL_Rect.klass, "right", VALUEFUNC(_wrap_CL_Rect_right_get), -1);
    rb_define_method(cCL_Rect.klass, "top=", VALUEFUNC(_wrap_CL_Rect_top_set), -1);
    rb_define_method(cCL_Rect.klass, "top", VALUEFUNC(_wrap_CL_Rect_top_get), -1);
    rb_define_method(cCL_Rect.klass, "bottom=", VALUEFUNC(_wrap_CL_Rect_bottom_set), -1);
    rb_define_method(cCL_Rect.klass, "bottom", VALUEFUNC(_wrap_CL_Rect_bottom_get), -1);
    rb_define_method(cCL_Rect.klass, "get_width", VALUEFUNC(_wrap_CL_Rect_get_width), -1);
    rb_define_method(cCL_Rect.klass, "get_height", VALUEFUNC(_wrap_CL_Rect_get_height), -1);
    rb_define_method(cCL_Rect.klass, "get_size", VALUEFUNC(_wrap_CL_Rect_get_size), -1);
    cCL_Rect.mark = 0;
    cCL_Rect.destroy = (void (*)(void *)) free_CL_Rect;
    
    cCL_Color.klass = rb_define_class_under(mFlexlay_wrap, "CL_Color", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Color, (void *) &cCL_Color);
    rb_define_alloc_func(cCL_Color.klass, _wrap_CL_Color_allocate);
    rb_define_method(cCL_Color.klass, "initialize", VALUEFUNC(_wrap_new_CL_Color), -1);
    rb_define_method(cCL_Color.klass, "set_red", VALUEFUNC(_wrap_CL_Color_set_red), -1);
    rb_define_method(cCL_Color.klass, "set_blue", VALUEFUNC(_wrap_CL_Color_set_blue), -1);
    rb_define_method(cCL_Color.klass, "set_green", VALUEFUNC(_wrap_CL_Color_set_green), -1);
    rb_define_method(cCL_Color.klass, "set_alpha", VALUEFUNC(_wrap_CL_Color_set_alpha), -1);
    rb_define_method(cCL_Color.klass, "get_red", VALUEFUNC(_wrap_CL_Color_get_red), -1);
    rb_define_method(cCL_Color.klass, "get_blue", VALUEFUNC(_wrap_CL_Color_get_blue), -1);
    rb_define_method(cCL_Color.klass, "get_green", VALUEFUNC(_wrap_CL_Color_get_green), -1);
    rb_define_method(cCL_Color.klass, "get_alpha", VALUEFUNC(_wrap_CL_Color_get_alpha), -1);
    cCL_Color.mark = 0;
    cCL_Color.destroy = (void (*)(void *)) free_CL_Color;
    
    cCL_Window.klass = rb_define_class_under(mFlexlay_wrap, "CL_Window", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Window, (void *) &cCL_Window);
    rb_define_alloc_func(cCL_Window.klass, _wrap_CL_Window_allocate);
    rb_define_method(cCL_Window.klass, "initialize", VALUEFUNC(_wrap_new_CL_Window), -1);
    rb_define_method(cCL_Window.klass, "get_client_area", VALUEFUNC(_wrap_CL_Window_get_client_area), -1);
    cCL_Window.mark = 0;
    
    cCL_Button.klass = rb_define_class_under(mFlexlay_wrap, "CL_Button", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Button, (void *) &cCL_Button);
    rb_define_alloc_func(cCL_Button.klass, _wrap_CL_Button_allocate);
    rb_define_method(cCL_Button.klass, "initialize", VALUEFUNC(_wrap_new_CL_Button), -1);
    rb_define_method(cCL_Button.klass, "sig_clicked", VALUEFUNC(_wrap_CL_Button_sig_clicked), -1);
    cCL_Button.mark = 0;
    
    cCL_Menu.klass = rb_define_class_under(mFlexlay_wrap, "CL_Menu", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Menu, (void *) &cCL_Menu);
    rb_define_alloc_func(cCL_Menu.klass, _wrap_CL_Menu_allocate);
    rb_define_method(cCL_Menu.klass, "initialize", VALUEFUNC(_wrap_new_CL_Menu), -1);
    rb_define_method(cCL_Menu.klass, "create_item", VALUEFUNC(_wrap_CL_Menu_create_item), -1);
    cCL_Menu.mark = 0;
    
    cCL_MenuNode.klass = rb_define_class_under(mFlexlay_wrap, "CL_MenuNode", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_CL_MenuNode, (void *) &cCL_MenuNode);
    rb_define_alloc_func(cCL_MenuNode.klass, _wrap_CL_MenuNode_allocate);
    rb_define_method(cCL_MenuNode.klass, "initialize", VALUEFUNC(_wrap_new_CL_MenuNode), -1);
    rb_define_method(cCL_MenuNode.klass, "sig_clicked", VALUEFUNC(_wrap_CL_MenuNode_sig_clicked), -1);
    cCL_MenuNode.mark = 0;
    
    cCL_InputBox.klass = rb_define_class_under(mFlexlay_wrap, "CL_InputBox", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_CL_InputBox, (void *) &cCL_InputBox);
    rb_define_alloc_func(cCL_InputBox.klass, _wrap_CL_InputBox_allocate);
    rb_define_method(cCL_InputBox.klass, "initialize", VALUEFUNC(_wrap_new_CL_InputBox), -1);
    rb_define_method(cCL_InputBox.klass, "set_text", VALUEFUNC(_wrap_CL_InputBox_set_text), -1);
    rb_define_method(cCL_InputBox.klass, "get_text", VALUEFUNC(_wrap_CL_InputBox_get_text), -1);
    cCL_InputBox.mark = 0;
    
    cCL_Label.klass = rb_define_class_under(mFlexlay_wrap, "CL_Label", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_CL_Label, (void *) &cCL_Label);
    rb_define_alloc_func(cCL_Label.klass, _wrap_CL_Label_allocate);
    rb_define_method(cCL_Label.klass, "initialize", VALUEFUNC(_wrap_new_CL_Label), -1);
    cCL_Label.mark = 0;
    
    cCL_ListBox.klass = rb_define_class_under(mFlexlay_wrap, "CL_ListBox", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_CL_ListBox, (void *) &cCL_ListBox);
    rb_define_alloc_func(cCL_ListBox.klass, _wrap_CL_ListBox_allocate);
    rb_define_method(cCL_ListBox.klass, "initialize", VALUEFUNC(_wrap_new_CL_ListBox), -1);
    rb_define_method(cCL_ListBox.klass, "sig_highlighted", VALUEFUNC(_wrap_CL_ListBox_sig_highlighted), -1);
    rb_define_method(cCL_ListBox.klass, "insert_item", VALUEFUNC(_wrap_CL_ListBox_insert_item), -1);
    cCL_ListBox.mark = 0;
    
    cCL_ResourceManager.klass = rb_define_class_under(mFlexlay_wrap, "CL_ResourceManager", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CL_ResourceManager, (void *) &cCL_ResourceManager);
    rb_define_alloc_func(cCL_ResourceManager.klass, _wrap_CL_ResourceManager_allocate);
    rb_define_method(cCL_ResourceManager.klass, "initialize", VALUEFUNC(_wrap_new_CL_ResourceManager), -1);
    rb_define_method(cCL_ResourceManager.klass, "get_all_resources", VALUEFUNC(_wrap_CL_ResourceManager_get_all_resources), -1);
    rb_define_method(cCL_ResourceManager.klass, "get_all_sections", VALUEFUNC(_wrap_CL_ResourceManager_get_all_sections), -1);
    rb_define_method(cCL_ResourceManager.klass, "get_resources_of_type", VALUEFUNC(_wrap_CL_ResourceManager_get_resources_of_type), -1);
    rb_define_method(cCL_ResourceManager.klass, "add_resources", VALUEFUNC(_wrap_CL_ResourceManager_add_resources), -1);
    rb_define_method(cCL_ResourceManager.klass, "remove_resources", VALUEFUNC(_wrap_CL_ResourceManager_remove_resources), -1);
    cCL_ResourceManager.mark = 0;
    cCL_ResourceManager.destroy = (void (*)(void *)) free_CL_ResourceManager;
    
    cCommand.klass = rb_define_class_under(mFlexlay_wrap, "Command", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Command, (void *) &cCommand);
    rb_define_alloc_func(cCommand.klass, _wrap_Command_allocate);
    rb_define_method(cCommand.klass, "initialize", VALUEFUNC(_wrap_new_Command), -1);
    rb_define_method(cCommand.klass, "execute", VALUEFUNC(_wrap_Command_execute), -1);
    rb_define_method(cCommand.klass, "redo", VALUEFUNC(_wrap_Command_redo), -1);
    rb_define_method(cCommand.klass, "undo", VALUEFUNC(_wrap_Command_undo), -1);
    rb_define_method(cCommand.klass, "serialize", VALUEFUNC(_wrap_Command_serialize), -1);
    cCommand.mark = 0;
    cCommand.destroy = (void (*)(void *)) free_Command;
    
    cPaintCommand.klass = rb_define_class_under(mFlexlay_wrap, "PaintCommand", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_PaintCommand, (void *) &cPaintCommand);
    rb_define_alloc_func(cPaintCommand.klass, _wrap_PaintCommand_allocate);
    rb_define_method(cPaintCommand.klass, "initialize", VALUEFUNC(_wrap_new_PaintCommand), -1);
    rb_define_method(cPaintCommand.klass, "add_point", VALUEFUNC(_wrap_PaintCommand_add_point), -1);
    rb_define_method(cPaintCommand.klass, "to_command", VALUEFUNC(_wrap_PaintCommand_to_command), -1);
    cPaintCommand.mark = 0;
    cPaintCommand.destroy = (void (*)(void *)) free_PaintCommand;
    
    cObjectMoveCommand.klass = rb_define_class_under(mFlexlay_wrap, "ObjectMoveCommand", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjectMoveCommand, (void *) &cObjectMoveCommand);
    rb_define_alloc_func(cObjectMoveCommand.klass, _wrap_ObjectMoveCommand_allocate);
    rb_define_method(cObjectMoveCommand.klass, "initialize", VALUEFUNC(_wrap_new_ObjectMoveCommand), -1);
    rb_define_method(cObjectMoveCommand.klass, "add_obj", VALUEFUNC(_wrap_ObjectMoveCommand_add_obj), -1);
    rb_define_method(cObjectMoveCommand.klass, "move_by", VALUEFUNC(_wrap_ObjectMoveCommand_move_by), -1);
    rb_define_method(cObjectMoveCommand.klass, "to_command", VALUEFUNC(_wrap_ObjectMoveCommand_to_command), -1);
    cObjectMoveCommand.mark = 0;
    cObjectMoveCommand.destroy = (void (*)(void *)) free_ObjectMoveCommand;
    
    cObjectAddCommand.klass = rb_define_class_under(mFlexlay_wrap, "ObjectAddCommand", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjectAddCommand, (void *) &cObjectAddCommand);
    rb_define_alloc_func(cObjectAddCommand.klass, _wrap_ObjectAddCommand_allocate);
    rb_define_method(cObjectAddCommand.klass, "initialize", VALUEFUNC(_wrap_new_ObjectAddCommand), -1);
    rb_define_method(cObjectAddCommand.klass, "add_object", VALUEFUNC(_wrap_ObjectAddCommand_add_object), -1);
    rb_define_method(cObjectAddCommand.klass, "to_command", VALUEFUNC(_wrap_ObjectAddCommand_to_command), -1);
    cObjectAddCommand.mark = 0;
    cObjectAddCommand.destroy = (void (*)(void *)) free_ObjectAddCommand;
    
    cObjectDeleteCommand.klass = rb_define_class_under(mFlexlay_wrap, "ObjectDeleteCommand", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjectDeleteCommand, (void *) &cObjectDeleteCommand);
    rb_define_alloc_func(cObjectDeleteCommand.klass, _wrap_ObjectDeleteCommand_allocate);
    rb_define_method(cObjectDeleteCommand.klass, "initialize", VALUEFUNC(_wrap_new_ObjectDeleteCommand), -1);
    rb_define_method(cObjectDeleteCommand.klass, "add_object", VALUEFUNC(_wrap_ObjectDeleteCommand_add_object), -1);
    rb_define_method(cObjectDeleteCommand.klass, "to_command", VALUEFUNC(_wrap_ObjectDeleteCommand_to_command), -1);
    cObjectDeleteCommand.mark = 0;
    cObjectDeleteCommand.destroy = (void (*)(void *)) free_ObjectDeleteCommand;
    
    cTile.klass = rb_define_class_under(mFlexlay_wrap, "Tile", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Tile, (void *) &cTile);
    rb_define_alloc_func(cTile.klass, _wrap_Tile_allocate);
    rb_define_method(cTile.klass, "initialize", VALUEFUNC(_wrap_new_Tile), -1);
    rb_define_method(cTile.klass, "get_sprite", VALUEFUNC(_wrap_Tile_get_sprite), -1);
    rb_define_method(cTile.klass, "get_pixelbuffer", VALUEFUNC(_wrap_Tile_get_pixelbuffer), -1);
    rb_define_method(cTile.klass, "get_color", VALUEFUNC(_wrap_Tile_get_color), -1);
    rb_define_method(cTile.klass, "get_attribute_color", VALUEFUNC(_wrap_Tile_get_attribute_color), -1);
    rb_define_method(cTile.klass, "get_filename", VALUEFUNC(_wrap_Tile_get_filename), -1);
    rb_define_method(cTile.klass, "get_col", VALUEFUNC(_wrap_Tile_get_col), -1);
    rb_define_method(cTile.klass, "set_col", VALUEFUNC(_wrap_Tile_set_col), -1);
    rb_define_method(cTile.klass, "calc_color", VALUEFUNC(_wrap_Tile_calc_color), -1);
    cTile.mark = 0;
    cTile.destroy = (void (*)(void *)) free_Tile;
    
    cTileBrush.klass = rb_define_class_under(mFlexlay_wrap, "TileBrush", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_TileBrush, (void *) &cTileBrush);
    rb_define_alloc_func(cTileBrush.klass, _wrap_TileBrush_allocate);
    rb_define_method(cTileBrush.klass, "initialize", VALUEFUNC(_wrap_new_TileBrush), -1);
    rb_define_method(cTileBrush.klass, "get_width", VALUEFUNC(_wrap_TileBrush_get_width), -1);
    rb_define_method(cTileBrush.klass, "get_height", VALUEFUNC(_wrap_TileBrush_get_height), -1);
    rb_define_method(cTileBrush.klass, "set_data", VALUEFUNC(_wrap_TileBrush_set_data), -1);
    rb_define_method(cTileBrush.klass, "get_data", VALUEFUNC(_wrap_TileBrush_get_data), -1);
    rb_define_method(cTileBrush.klass, "at", VALUEFUNC(_wrap_TileBrush_at), -1);
    rb_define_method(cTileBrush.klass, "resize", VALUEFUNC(_wrap_TileBrush_resize), -1);
    rb_define_method(cTileBrush.klass, "set_opaque", VALUEFUNC(_wrap_TileBrush_set_opaque), -1);
    rb_define_method(cTileBrush.klass, "set_transparent", VALUEFUNC(_wrap_TileBrush_set_transparent), -1);
    rb_define_method(cTileBrush.klass, "is_opaque", VALUEFUNC(_wrap_TileBrush_is_opaque), -1);
    rb_define_method(cTileBrush.klass, "auto_crop", VALUEFUNC(_wrap_TileBrush_auto_crop), -1);
    cTileBrush.mark = 0;
    cTileBrush.destroy = (void (*)(void *)) free_TileBrush;
    
    cEditor.klass = rb_define_class_under(mFlexlay_wrap, "Editor", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Editor, (void *) &cEditor);
    rb_define_alloc_func(cEditor.klass, _wrap_Editor_allocate);
    rb_define_method(cEditor.klass, "initialize", VALUEFUNC(_wrap_new_Editor), -1);
    rb_define_method(cEditor.klass, "get_gui_manager", VALUEFUNC(_wrap_Editor_get_gui_manager), -1);
    rb_define_method(cEditor.klass, "run", VALUEFUNC(_wrap_Editor_run), -1);
    cEditor.mark = 0;
    cEditor.destroy = (void (*)(void *)) free_Editor;
    
    cMetaData.klass = rb_define_class_under(mFlexlay_wrap, "MetaData", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_MetaData, (void *) &cMetaData);
    rb_define_alloc_func(cMetaData.klass, _wrap_MetaData_allocate);
    rb_define_method(cMetaData.klass, "initialize", VALUEFUNC(_wrap_new_MetaData), -1);
    rb_define_method(cMetaData.klass, "get_impl", VALUEFUNC(_wrap_MetaData_get_impl), -1);
    cMetaData.mark = 0;
    cMetaData.destroy = (void (*)(void *)) free_MetaData;
    
    cConsole.klass = rb_define_class_under(mFlexlay_wrap, "Console", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Console, (void *) &cConsole);
    rb_define_alloc_func(cConsole.klass, _wrap_Console_allocate);
    rb_define_method(cConsole.klass, "initialize", VALUEFUNC(_wrap_new_Console), -1);
    rb_define_method(cConsole.klass, "write", VALUEFUNC(_wrap_Console_write), -1);
    rb_define_method(cConsole.klass, "clearscr", VALUEFUNC(_wrap_Console_clearscr), -1);
    cConsole.mark = 0;
    cConsole.destroy = (void (*)(void *)) free_Console;
    
    cLayer.klass = rb_define_class_under(mFlexlay_wrap, "Layer", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Layer, (void *) &cLayer);
    rb_define_alloc_func(cLayer.klass, _wrap_Layer_allocate);
    rb_define_method(cLayer.klass, "initialize", VALUEFUNC(_wrap_new_Layer), -1);
    rb_define_method(cLayer.klass, "get_metadata", VALUEFUNC(_wrap_Layer_get_metadata), -1);
    rb_define_method(cLayer.klass, "set_metadata", VALUEFUNC(_wrap_Layer_set_metadata), -1);
    rb_define_method(cLayer.klass, "draw", VALUEFUNC(_wrap_Layer_draw), -1);
    rb_define_method(cLayer.klass, "has_bounding_rect", VALUEFUNC(_wrap_Layer_has_bounding_rect), -1);
    rb_define_method(cLayer.klass, "get_bounding_rect", VALUEFUNC(_wrap_Layer_get_bounding_rect), -1);
    cLayer.mark = 0;
    cLayer.destroy = (void (*)(void *)) free_Layer;
    
    cTilemapLayer.klass = rb_define_class_under(mFlexlay_wrap, "TilemapLayer", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_TilemapLayer, (void *) &cTilemapLayer);
    rb_define_alloc_func(cTilemapLayer.klass, _wrap_TilemapLayer_allocate);
    rb_define_method(cTilemapLayer.klass, "initialize", VALUEFUNC(_wrap_new_TilemapLayer), -1);
    rb_define_singleton_method(cTilemapLayer.klass, "current", VALUEFUNC(_wrap_TilemapLayer_current), -1);
    rb_define_singleton_method(cTilemapLayer.klass, "set_current", VALUEFUNC(_wrap_TilemapLayer_set_current), -1);
    rb_define_method(cTilemapLayer.klass, "draw", VALUEFUNC(_wrap_TilemapLayer_draw), -1);
    rb_define_method(cTilemapLayer.klass, "get_tileset", VALUEFUNC(_wrap_TilemapLayer_get_tileset), -1);
    rb_define_method(cTilemapLayer.klass, "get_tile", VALUEFUNC(_wrap_TilemapLayer_get_tile), -1);
    rb_define_method(cTilemapLayer.klass, "get_field", VALUEFUNC(_wrap_TilemapLayer_get_field), -1);
    rb_define_method(cTilemapLayer.klass, "resize", VALUEFUNC(_wrap_TilemapLayer_resize), -1);
    rb_define_method(cTilemapLayer.klass, "get_data", VALUEFUNC(_wrap_TilemapLayer_get_data), -1);
    rb_define_method(cTilemapLayer.klass, "set_data", VALUEFUNC(_wrap_TilemapLayer_set_data), -1);
    rb_define_method(cTilemapLayer.klass, "get_width", VALUEFUNC(_wrap_TilemapLayer_get_width), -1);
    rb_define_method(cTilemapLayer.klass, "get_height", VALUEFUNC(_wrap_TilemapLayer_get_height), -1);
    rb_define_method(cTilemapLayer.klass, "set_background_color", VALUEFUNC(_wrap_TilemapLayer_set_background_color), -1);
    rb_define_method(cTilemapLayer.klass, "set_foreground_color", VALUEFUNC(_wrap_TilemapLayer_set_foreground_color), -1);
    rb_define_method(cTilemapLayer.klass, "set_draw_attribute", VALUEFUNC(_wrap_TilemapLayer_set_draw_attribute), -1);
    rb_define_method(cTilemapLayer.klass, "get_draw_attribute", VALUEFUNC(_wrap_TilemapLayer_get_draw_attribute), -1);
    rb_define_method(cTilemapLayer.klass, "set_draw_grid", VALUEFUNC(_wrap_TilemapLayer_set_draw_grid), -1);
    rb_define_method(cTilemapLayer.klass, "get_draw_grid", VALUEFUNC(_wrap_TilemapLayer_get_draw_grid), -1);
    rb_define_method(cTilemapLayer.klass, "create_pixelbuffer", VALUEFUNC(_wrap_TilemapLayer_create_pixelbuffer), -1);
    rb_define_singleton_method(cTilemapLayer.klass, "draw_tile", VALUEFUNC(_wrap_TilemapLayer_draw_tile), -1);
    rb_define_method(cTilemapLayer.klass, "has_bounding_rect", VALUEFUNC(_wrap_TilemapLayer_has_bounding_rect), -1);
    rb_define_method(cTilemapLayer.klass, "get_bounding_rect", VALUEFUNC(_wrap_TilemapLayer_get_bounding_rect), -1);
    rb_define_method(cTilemapLayer.klass, "world2tile", VALUEFUNC(_wrap_TilemapLayer_world2tile), -1);
    rb_define_method(cTilemapLayer.klass, "is_null", VALUEFUNC(_wrap_TilemapLayer_is_null), -1);
    rb_define_method(cTilemapLayer.klass, "to_layer", VALUEFUNC(_wrap_TilemapLayer_to_layer), -1);
    cTilemapLayer.mark = 0;
    cTilemapLayer.destroy = (void (*)(void *)) free_TilemapLayer;
    
    cObjectLayer.klass = rb_define_class_under(mFlexlay_wrap, "ObjectLayer", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjectLayer, (void *) &cObjectLayer);
    rb_define_alloc_func(cObjectLayer.klass, _wrap_ObjectLayer_allocate);
    rb_define_method(cObjectLayer.klass, "initialize", VALUEFUNC(_wrap_new_ObjectLayer), -1);
    rb_define_singleton_method(cObjectLayer.klass, "current_", VALUEFUNC(ObjectLayer_current__get), 0);
    rb_define_singleton_method(cObjectLayer.klass, "current_=", VALUEFUNC(ObjectLayer_current__set), 1);
    rb_define_singleton_method(cObjectLayer.klass, "current", VALUEFUNC(_wrap_ObjectLayer_current), -1);
    rb_define_singleton_method(cObjectLayer.klass, "set_current", VALUEFUNC(_wrap_ObjectLayer_set_current), -1);
    rb_define_method(cObjectLayer.klass, "add_object", VALUEFUNC(_wrap_ObjectLayer_add_object), -1);
    rb_define_method(cObjectLayer.klass, "delete_object", VALUEFUNC(_wrap_ObjectLayer_delete_object), -1);
    rb_define_method(cObjectLayer.klass, "find_object", VALUEFUNC(_wrap_ObjectLayer_find_object), -1);
    rb_define_method(cObjectLayer.klass, "get_selection", VALUEFUNC(_wrap_ObjectLayer_get_selection), -1);
    rb_define_method(cObjectLayer.klass, "get_objects", VALUEFUNC(_wrap_ObjectLayer_get_objects), -1);
    rb_define_method(cObjectLayer.klass, "to_layer", VALUEFUNC(_wrap_ObjectLayer_to_layer), -1);
    cObjectLayer.mark = 0;
    cObjectLayer.destroy = (void (*)(void *)) free_ObjectLayer;
    
    cEditorMap.klass = rb_define_class_under(mFlexlay_wrap, "EditorMap", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_EditorMap, (void *) &cEditorMap);
    rb_define_alloc_func(cEditorMap.klass, _wrap_EditorMap_allocate);
    rb_define_method(cEditorMap.klass, "initialize", VALUEFUNC(_wrap_new_EditorMap), -1);
    rb_define_method(cEditorMap.klass, "draw", VALUEFUNC(_wrap_EditorMap_draw), -1);
    rb_define_method(cEditorMap.klass, "add_layer", VALUEFUNC(_wrap_EditorMap_add_layer), -1);
    rb_define_method(cEditorMap.klass, "is_modified", VALUEFUNC(_wrap_EditorMap_is_modified), -1);
    rb_define_method(cEditorMap.klass, "set_unmodified", VALUEFUNC(_wrap_EditorMap_set_unmodified), -1);
    rb_define_method(cEditorMap.klass, "modify", VALUEFUNC(_wrap_EditorMap_modify), -1);
    rb_define_method(cEditorMap.klass, "get_serial", VALUEFUNC(_wrap_EditorMap_get_serial), -1);
    rb_define_method(cEditorMap.klass, "get_layer", VALUEFUNC(_wrap_EditorMap_get_layer), -1);
    rb_define_method(cEditorMap.klass, "set_metadata", VALUEFUNC(_wrap_EditorMap_set_metadata), -1);
    rb_define_method(cEditorMap.klass, "get_metadata", VALUEFUNC(_wrap_EditorMap_get_metadata), -1);
    rb_define_method(cEditorMap.klass, "has_bounding_rect", VALUEFUNC(_wrap_EditorMap_has_bounding_rect), -1);
    rb_define_method(cEditorMap.klass, "get_bounding_rect", VALUEFUNC(_wrap_EditorMap_get_bounding_rect), -1);
    rb_define_method(cEditorMap.klass, "set_background_color", VALUEFUNC(_wrap_EditorMap_set_background_color), -1);
    rb_define_method(cEditorMap.klass, "execute", VALUEFUNC(_wrap_EditorMap_execute), -1);
    rb_define_method(cEditorMap.klass, "undo", VALUEFUNC(_wrap_EditorMap_undo), -1);
    rb_define_method(cEditorMap.klass, "redo", VALUEFUNC(_wrap_EditorMap_redo), -1);
    rb_define_method(cEditorMap.klass, "undo_stack_size", VALUEFUNC(_wrap_EditorMap_undo_stack_size), -1);
    rb_define_method(cEditorMap.klass, "redo_stack_size", VALUEFUNC(_wrap_EditorMap_redo_stack_size), -1);
    rb_define_method(cEditorMap.klass, "sig_change", VALUEFUNC(_wrap_EditorMap_sig_change), -1);
    cEditorMap.mark = 0;
    cEditorMap.destroy = (void (*)(void *)) free_EditorMap;
    
    cWorkspace.klass = rb_define_class_under(mFlexlay_wrap, "Workspace", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Workspace, (void *) &cWorkspace);
    rb_define_alloc_func(cWorkspace.klass, _wrap_Workspace_allocate);
    rb_define_method(cWorkspace.klass, "initialize", VALUEFUNC(_wrap_new_Workspace), -1);
    rb_define_singleton_method(cWorkspace.klass, "set_current", VALUEFUNC(_wrap_Workspace_set_current), -1);
    rb_define_singleton_method(cWorkspace.klass, "current", VALUEFUNC(_wrap_Workspace_current), -1);
    rb_define_method(cWorkspace.klass, "draw", VALUEFUNC(_wrap_Workspace_draw), -1);
    rb_define_method(cWorkspace.klass, "mouse_up", VALUEFUNC(_wrap_Workspace_mouse_up), -1);
    rb_define_method(cWorkspace.klass, "mouse_down", VALUEFUNC(_wrap_Workspace_mouse_down), -1);
    rb_define_method(cWorkspace.klass, "mouse_move", VALUEFUNC(_wrap_Workspace_mouse_move), -1);
    rb_define_method(cWorkspace.klass, "get_map", VALUEFUNC(_wrap_Workspace_get_map), -1);
    rb_define_method(cWorkspace.klass, "set_map", VALUEFUNC(_wrap_Workspace_set_map), -1);
    rb_define_method(cWorkspace.klass, "get_gc_state", VALUEFUNC(_wrap_Workspace_get_gc_state), -1);
    rb_define_method(cWorkspace.klass, "set_tool", VALUEFUNC(_wrap_Workspace_set_tool), -1);
    cWorkspace.mark = 0;
    cWorkspace.destroy = (void (*)(void *)) free_Workspace;
    
    cTileset.klass = rb_define_class_under(mFlexlay_wrap, "Tileset", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Tileset, (void *) &cTileset);
    rb_define_alloc_func(cTileset.klass, _wrap_Tileset_allocate);
    rb_define_method(cTileset.klass, "initialize", VALUEFUNC(_wrap_new_Tileset), -1);
    rb_define_method(cTileset.klass, "create", VALUEFUNC(_wrap_Tileset_create), -1);
    rb_define_method(cTileset.klass, "get_tile_size", VALUEFUNC(_wrap_Tileset_get_tile_size), -1);
    rb_define_method(cTileset.klass, "add_tile", VALUEFUNC(_wrap_Tileset_add_tile), -1);
    rb_define_method(cTileset.klass, "get_tiles", VALUEFUNC(_wrap_Tileset_get_tiles), -1);
    cTileset.mark = 0;
    cTileset.destroy = (void (*)(void *)) free_Tileset;
    
    cEditorMapComponent.klass = rb_define_class_under(mFlexlay_wrap, "EditorMapComponent", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_EditorMapComponent, (void *) &cEditorMapComponent);
    rb_define_alloc_func(cEditorMapComponent.klass, _wrap_EditorMapComponent_allocate);
    rb_define_method(cEditorMapComponent.klass, "initialize", VALUEFUNC(_wrap_new_EditorMapComponent), -1);
    rb_define_singleton_method(cEditorMapComponent.klass, "current", VALUEFUNC(_wrap_EditorMapComponent_current), -1);
    rb_define_method(cEditorMapComponent.klass, "get_workspace", VALUEFUNC(_wrap_EditorMapComponent_get_workspace), -1);
    rb_define_method(cEditorMapComponent.klass, "set_workspace", VALUEFUNC(_wrap_EditorMapComponent_set_workspace), -1);
    rb_define_method(cEditorMapComponent.klass, "set_zoom", VALUEFUNC(_wrap_EditorMapComponent_set_zoom), -1);
    rb_define_method(cEditorMapComponent.klass, "zoom_to", VALUEFUNC(_wrap_EditorMapComponent_zoom_to), -1);
    rb_define_method(cEditorMapComponent.klass, "zoom_out", VALUEFUNC(_wrap_EditorMapComponent_zoom_out), -1);
    rb_define_method(cEditorMapComponent.klass, "zoom_in", VALUEFUNC(_wrap_EditorMapComponent_zoom_in), -1);
    rb_define_method(cEditorMapComponent.klass, "move_to", VALUEFUNC(_wrap_EditorMapComponent_move_to), -1);
    rb_define_method(cEditorMapComponent.klass, "move_to_x", VALUEFUNC(_wrap_EditorMapComponent_move_to_x), -1);
    rb_define_method(cEditorMapComponent.klass, "move_to_y", VALUEFUNC(_wrap_EditorMapComponent_move_to_y), -1);
    rb_define_method(cEditorMapComponent.klass, "sig_on_key", VALUEFUNC(_wrap_EditorMapComponent_sig_on_key), -1);
    rb_define_method(cEditorMapComponent.klass, "screen2world", VALUEFUNC(_wrap_EditorMapComponent_screen2world), -1);
    rb_define_method(cEditorMapComponent.klass, "get_clip_rect", VALUEFUNC(_wrap_EditorMapComponent_get_clip_rect), -1);
    cEditorMapComponent.mark = 0;
    cEditorMapComponent.destroy = (void (*)(void *)) free_EditorMapComponent;
    
    cFlexlay.klass = rb_define_class_under(mFlexlay_wrap, "Flexlay", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Flexlay, (void *) &cFlexlay);
    rb_define_alloc_func(cFlexlay.klass, _wrap_Flexlay_allocate);
    rb_define_method(cFlexlay.klass, "initialize", VALUEFUNC(_wrap_new_Flexlay), -1);
    rb_define_method(cFlexlay.klass, "screen_width=", VALUEFUNC(_wrap_Flexlay_screen_width_set), -1);
    rb_define_method(cFlexlay.klass, "screen_width", VALUEFUNC(_wrap_Flexlay_screen_width_get), -1);
    rb_define_method(cFlexlay.klass, "screen_height=", VALUEFUNC(_wrap_Flexlay_screen_height_set), -1);
    rb_define_method(cFlexlay.klass, "screen_height", VALUEFUNC(_wrap_Flexlay_screen_height_get), -1);
    rb_define_method(cFlexlay.klass, "fullscreen=", VALUEFUNC(_wrap_Flexlay_fullscreen_set), -1);
    rb_define_method(cFlexlay.klass, "fullscreen", VALUEFUNC(_wrap_Flexlay_fullscreen_get), -1);
    rb_define_method(cFlexlay.klass, "allow_resize=", VALUEFUNC(_wrap_Flexlay_allow_resize_set), -1);
    rb_define_method(cFlexlay.klass, "allow_resize", VALUEFUNC(_wrap_Flexlay_allow_resize_get), -1);
    rb_define_method(cFlexlay.klass, "use_opengl=", VALUEFUNC(_wrap_Flexlay_use_opengl_set), -1);
    rb_define_method(cFlexlay.klass, "use_opengl", VALUEFUNC(_wrap_Flexlay_use_opengl_get), -1);
    rb_define_method(cFlexlay.klass, "resources=", VALUEFUNC(_wrap_Flexlay_resources_set), -1);
    rb_define_method(cFlexlay.klass, "resources", VALUEFUNC(_wrap_Flexlay_resources_get), -1);
    rb_define_method(cFlexlay.klass, "init", VALUEFUNC(_wrap_Flexlay_init), -1);
    rb_define_method(cFlexlay.klass, "deinit", VALUEFUNC(_wrap_Flexlay_deinit), -1);
    cFlexlay.mark = 0;
    cFlexlay.destroy = (void (*)(void *)) free_Flexlay;
    rb_define_singleton_method(mFlexlay_wrap, "datadir", VALUEFUNC(datadir_get), 0);
    rb_define_singleton_method(mFlexlay_wrap, "datadir=", VALUEFUNC(datadir_set), 1);
    rb_define_singleton_method(mFlexlay_wrap, "bindir", VALUEFUNC(bindir_get), 0);
    rb_define_singleton_method(mFlexlay_wrap, "bindir=", VALUEFUNC(bindir_set), 1);
    rb_define_singleton_method(mFlexlay_wrap, "homedir", VALUEFUNC(homedir_get), 0);
    rb_define_singleton_method(mFlexlay_wrap, "homedir=", VALUEFUNC(homedir_set), 1);
    rb_define_singleton_method(mFlexlay_wrap, "debug", VALUEFUNC(debug_get), 0);
    rb_define_singleton_method(mFlexlay_wrap, "debug=", VALUEFUNC(debug_set), 1);
    
    cGUIManager.klass = rb_define_class_under(mFlexlay_wrap, "GUIManager", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_GUIManager, (void *) &cGUIManager);
    rb_define_alloc_func(cGUIManager.klass, _wrap_GUIManager_allocate);
    rb_define_method(cGUIManager.klass, "initialize", VALUEFUNC(_wrap_new_GUIManager), -1);
    rb_define_singleton_method(cGUIManager.klass, "current", VALUEFUNC(_wrap_GUIManager_current), -1);
    rb_define_method(cGUIManager.klass, "draw", VALUEFUNC(_wrap_GUIManager_draw), -1);
    rb_define_method(cGUIManager.klass, "update", VALUEFUNC(_wrap_GUIManager_update), -1);
    rb_define_method(cGUIManager.klass, "run", VALUEFUNC(_wrap_GUIManager_run), -1);
    rb_define_method(cGUIManager.klass, "quit", VALUEFUNC(_wrap_GUIManager_quit), -1);
    rb_define_method(cGUIManager.klass, "push_component", VALUEFUNC(_wrap_GUIManager_push_component), -1);
    rb_define_method(cGUIManager.klass, "pop_component", VALUEFUNC(_wrap_GUIManager_pop_component), -1);
    rb_define_method(cGUIManager.klass, "hide", VALUEFUNC(_wrap_GUIManager_hide), -1);
    rb_define_method(cGUIManager.klass, "show", VALUEFUNC(_wrap_GUIManager_show), -1);
    rb_define_method(cGUIManager.klass, "is_visible", VALUEFUNC(_wrap_GUIManager_is_visible), -1);
    rb_define_method(cGUIManager.klass, "get_component", VALUEFUNC(_wrap_GUIManager_get_component), -1);
    rb_define_method(cGUIManager.klass, "get_slot_container", VALUEFUNC(_wrap_GUIManager_get_slot_container), -1);
    cGUIManager.mark = 0;
    cGUIManager.destroy = (void (*)(void *)) free_GUIManager;
    
    cTileSelector.klass = rb_define_class_under(mFlexlay_wrap, "TileSelector", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_TileSelector, (void *) &cTileSelector);
    rb_define_alloc_func(cTileSelector.klass, _wrap_TileSelector_allocate);
    rb_define_method(cTileSelector.klass, "initialize", VALUEFUNC(_wrap_new_TileSelector), -1);
    rb_define_method(cTileSelector.klass, "set_tileset", VALUEFUNC(_wrap_TileSelector_set_tileset), -1);
    rb_define_method(cTileSelector.klass, "set_tiles", VALUEFUNC(_wrap_TileSelector_set_tiles), -1);
    rb_define_method(cTileSelector.klass, "get_tiles", VALUEFUNC(_wrap_TileSelector_get_tiles), -1);
    rb_define_method(cTileSelector.klass, "set_scale", VALUEFUNC(_wrap_TileSelector_set_scale), -1);
    rb_define_method(cTileSelector.klass, "draw", VALUEFUNC(_wrap_TileSelector_draw), -1);
    cTileSelector.mark = 0;
    cTileSelector.destroy = (void (*)(void *)) free_TileSelector;
    
    cObjectBrush.klass = rb_define_class_under(mFlexlay_wrap, "ObjectBrush", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjectBrush, (void *) &cObjectBrush);
    rb_define_alloc_func(cObjectBrush.klass, _wrap_ObjectBrush_allocate);
    rb_define_method(cObjectBrush.klass, "initialize", VALUEFUNC(_wrap_new_ObjectBrush), -1);
    rb_define_method(cObjectBrush.klass, "get_sprite", VALUEFUNC(_wrap_ObjectBrush_get_sprite), -1);
    rb_define_method(cObjectBrush.klass, "get_data", VALUEFUNC(_wrap_ObjectBrush_get_data), -1);
    rb_define_method(cObjectBrush.klass, "to_sprite_object", VALUEFUNC(_wrap_ObjectBrush_to_sprite_object), -1);
    cObjectBrush.mark = 0;
    cObjectBrush.destroy = (void (*)(void *)) free_ObjectBrush;
    
    cObjectSelector.klass = rb_define_class_under(mFlexlay_wrap, "ObjectSelector", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_ObjectSelector, (void *) &cObjectSelector);
    rb_define_alloc_func(cObjectSelector.klass, _wrap_ObjectSelector_allocate);
    rb_define_method(cObjectSelector.klass, "initialize", VALUEFUNC(_wrap_new_ObjectSelector), -1);
    rb_define_method(cObjectSelector.klass, "draw", VALUEFUNC(_wrap_ObjectSelector_draw), -1);
    rb_define_method(cObjectSelector.klass, "add_brush", VALUEFUNC(_wrap_ObjectSelector_add_brush), -1);
    rb_define_method(cObjectSelector.klass, "sig_drop", VALUEFUNC(_wrap_ObjectSelector_sig_drop), -1);
    cObjectSelector.mark = 0;
    cObjectSelector.destroy = (void (*)(void *)) free_ObjectSelector;
    
    cIcon.klass = rb_define_class_under(mFlexlay_wrap, "Icon", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Icon, (void *) &cIcon);
    rb_define_alloc_func(cIcon.klass, _wrap_Icon_allocate);
    rb_define_method(cIcon.klass, "initialize", VALUEFUNC(_wrap_new_Icon), -1);
    rb_define_method(cIcon.klass, "disable", VALUEFUNC(_wrap_Icon_disable), -1);
    rb_define_method(cIcon.klass, "enable", VALUEFUNC(_wrap_Icon_enable), -1);
    rb_define_method(cIcon.klass, "set_up", VALUEFUNC(_wrap_Icon_set_up), -1);
    rb_define_method(cIcon.klass, "set_down", VALUEFUNC(_wrap_Icon_set_down), -1);
    rb_define_method(cIcon.klass, "sig_clicked", VALUEFUNC(_wrap_Icon_sig_clicked), -1);
    cIcon.mark = 0;
    
    cWindow.klass = rb_define_class_under(mFlexlay_wrap, "Window", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Window, (void *) &cWindow);
    rb_define_alloc_func(cWindow.klass, _wrap_Window_allocate);
    rb_define_method(cWindow.klass, "initialize", VALUEFUNC(_wrap_new_Window), -1);
    rb_define_method(cWindow.klass, "hide", VALUEFUNC(_wrap_Window_hide), -1);
    rb_define_method(cWindow.klass, "show", VALUEFUNC(_wrap_Window_show), -1);
    rb_define_method(cWindow.klass, "get_client_area", VALUEFUNC(_wrap_Window_get_client_area), -1);
    cWindow.mark = 0;
    cWindow.destroy = (void (*)(void *)) free_Window;
    
    cPanel.klass = rb_define_class_under(mFlexlay_wrap, "Panel", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Panel, (void *) &cPanel);
    rb_define_alloc_func(cPanel.klass, _wrap_Panel_allocate);
    rb_define_method(cPanel.klass, "initialize", VALUEFUNC(_wrap_new_Panel), -1);
    cPanel.mark = 0;
    
    cMinimap.klass = rb_define_class_under(mFlexlay_wrap, "Minimap", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Minimap, (void *) &cMinimap);
    rb_define_alloc_func(cMinimap.klass, _wrap_Minimap_allocate);
    rb_define_method(cMinimap.klass, "initialize", VALUEFUNC(_wrap_new_Minimap), -1);
    rb_define_method(cMinimap.klass, "draw", VALUEFUNC(_wrap_Minimap_draw), -1);
    rb_define_method(cMinimap.klass, "update_minimap", VALUEFUNC(_wrap_Minimap_update_minimap), -1);
    rb_define_method(cMinimap.klass, "mouse_move", VALUEFUNC(_wrap_Minimap_mouse_move), -1);
    rb_define_method(cMinimap.klass, "mouse_down", VALUEFUNC(_wrap_Minimap_mouse_down), -1);
    rb_define_method(cMinimap.klass, "mouse_up", VALUEFUNC(_wrap_Minimap_mouse_up), -1);
    cMinimap.mark = 0;
    
    cDirectoryView.klass = rb_define_class_under(mFlexlay_wrap, "DirectoryView", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_DirectoryView, (void *) &cDirectoryView);
    rb_define_alloc_func(cDirectoryView.klass, _wrap_DirectoryView_allocate);
    rb_define_method(cDirectoryView.klass, "initialize", VALUEFUNC(_wrap_new_DirectoryView), -1);
    rb_define_method(cDirectoryView.klass, "set_directory", VALUEFUNC(_wrap_DirectoryView_set_directory), -1);
    rb_define_method(cDirectoryView.klass, "sig_on_click", VALUEFUNC(_wrap_DirectoryView_sig_on_click), -1);
    cDirectoryView.mark = 0;
    cDirectoryView.destroy = (void (*)(void *)) free_DirectoryView;
    
    cMenu.klass = rb_define_class_under(mFlexlay_wrap, "Menu", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Menu, (void *) &cMenu);
    rb_define_alloc_func(cMenu.klass, _wrap_Menu_allocate);
    rb_define_method(cMenu.klass, "initialize", VALUEFUNC(_wrap_new_Menu), -1);
    rb_define_method(cMenu.klass, "clear", VALUEFUNC(_wrap_Menu_clear), -1);
    rb_define_method(cMenu.klass, "add_item", VALUEFUNC(_wrap_Menu_add_item), -1);
    rb_define_method(cMenu.klass, "add_submenu", VALUEFUNC(_wrap_Menu_add_submenu), -1);
    rb_define_method(cMenu.klass, "add_seperator", VALUEFUNC(_wrap_Menu_add_seperator), -1);
    rb_define_method(cMenu.klass, "sig_clicked", VALUEFUNC(_wrap_Menu_sig_clicked), -1);
    rb_define_method(cMenu.klass, "run", VALUEFUNC(_wrap_Menu_run), -1);
    cMenu.mark = 0;
    cMenu.destroy = (void (*)(void *)) free_Menu;
    
    cMenubar.klass = rb_define_class_under(mFlexlay_wrap, "Menubar", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Menubar, (void *) &cMenubar);
    rb_define_alloc_func(cMenubar.klass, _wrap_Menubar_allocate);
    rb_define_method(cMenubar.klass, "initialize", VALUEFUNC(_wrap_new_Menubar), -1);
    rb_define_method(cMenubar.klass, "add_submenu", VALUEFUNC(_wrap_Menubar_add_submenu), -1);
    cMenubar.mark = 0;
    
    cScrollbar.klass = rb_define_class_under(mFlexlay_wrap, "Scrollbar", ((swig_class *) SWIGTYPE_p_CL_Component->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Scrollbar, (void *) &cScrollbar);
    rb_define_alloc_func(cScrollbar.klass, _wrap_Scrollbar_allocate);
    rb_define_method(cScrollbar.klass, "initialize", VALUEFUNC(_wrap_new_Scrollbar), -1);
    rb_define_const(cScrollbar.klass,"HORIZONTAL", INT2NUM(Scrollbar::HORIZONTAL));
    rb_define_const(cScrollbar.klass,"VERTICAL", INT2NUM(Scrollbar::VERTICAL));
    rb_define_method(cScrollbar.klass, "set_range", VALUEFUNC(_wrap_Scrollbar_set_range), -1);
    rb_define_method(cScrollbar.klass, "set_pagesize", VALUEFUNC(_wrap_Scrollbar_set_pagesize), -1);
    rb_define_method(cScrollbar.klass, "set_pos", VALUEFUNC(_wrap_Scrollbar_set_pos), -1);
    rb_define_method(cScrollbar.klass, "sig_scrollbar_move", VALUEFUNC(_wrap_Scrollbar_sig_scrollbar_move), -1);
    cScrollbar.mark = 0;
    
    cTileMapPaintTool.klass = rb_define_class_under(mFlexlay_wrap, "TileMapPaintTool", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_TileMapPaintTool, (void *) &cTileMapPaintTool);
    rb_define_alloc_func(cTileMapPaintTool.klass, _wrap_TileMapPaintTool_allocate);
    rb_define_method(cTileMapPaintTool.klass, "initialize", VALUEFUNC(_wrap_new_TileMapPaintTool), -1);
    rb_define_singleton_method(cTileMapPaintTool.klass, "current", VALUEFUNC(_wrap_TileMapPaintTool_current), -1);
    rb_define_method(cTileMapPaintTool.klass, "get_brush", VALUEFUNC(_wrap_TileMapPaintTool_get_brush), -1);
    rb_define_method(cTileMapPaintTool.klass, "set_brush", VALUEFUNC(_wrap_TileMapPaintTool_set_brush), -1);
    rb_define_method(cTileMapPaintTool.klass, "to_tool", VALUEFUNC(_wrap_TileMapPaintTool_to_tool), -1);
    cTileMapPaintTool.mark = 0;
    cTileMapPaintTool.destroy = (void (*)(void *)) free_TileMapPaintTool;
    
    cTileMapSelectTool.klass = rb_define_class_under(mFlexlay_wrap, "TileMapSelectTool", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_TileMapSelectTool, (void *) &cTileMapSelectTool);
    rb_define_alloc_func(cTileMapSelectTool.klass, _wrap_TileMapSelectTool_allocate);
    rb_define_method(cTileMapSelectTool.klass, "initialize", VALUEFUNC(_wrap_new_TileMapSelectTool), -1);
    rb_define_method(cTileMapSelectTool.klass, "get_selection", VALUEFUNC(_wrap_TileMapSelectTool_get_selection), -1);
    rb_define_method(cTileMapSelectTool.klass, "get_selection_rect", VALUEFUNC(_wrap_TileMapSelectTool_get_selection_rect), -1);
    rb_define_method(cTileMapSelectTool.klass, "to_tool", VALUEFUNC(_wrap_TileMapSelectTool_to_tool), -1);
    cTileMapSelectTool.mark = 0;
    cTileMapSelectTool.destroy = (void (*)(void *)) free_TileMapSelectTool;
    
    cObjMapSelectTool.klass = rb_define_class_under(mFlexlay_wrap, "ObjMapSelectTool", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjMapSelectTool, (void *) &cObjMapSelectTool);
    rb_define_alloc_func(cObjMapSelectTool.klass, _wrap_ObjMapSelectTool_allocate);
    rb_define_method(cObjMapSelectTool.klass, "initialize", VALUEFUNC(_wrap_new_ObjMapSelectTool), -1);
    rb_define_method(cObjMapSelectTool.klass, "clear_selection", VALUEFUNC(_wrap_ObjMapSelectTool_clear_selection), -1);
    rb_define_method(cObjMapSelectTool.klass, "get_selection", VALUEFUNC(_wrap_ObjMapSelectTool_get_selection), -1);
    rb_define_method(cObjMapSelectTool.klass, "set_selection", VALUEFUNC(_wrap_ObjMapSelectTool_set_selection), -1);
    rb_define_method(cObjMapSelectTool.klass, "sig_on_popup_menu_display", VALUEFUNC(_wrap_ObjMapSelectTool_sig_on_popup_menu_display), -1);
    rb_define_method(cObjMapSelectTool.klass, "to_tool", VALUEFUNC(_wrap_ObjMapSelectTool_to_tool), -1);
    cObjMapSelectTool.mark = 0;
    cObjMapSelectTool.destroy = (void (*)(void *)) free_ObjMapSelectTool;
    
    cObjMapSpriteObject.klass = rb_define_class_under(mFlexlay_wrap, "ObjMapSpriteObject", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjMapSpriteObject, (void *) &cObjMapSpriteObject);
    rb_define_alloc_func(cObjMapSpriteObject.klass, _wrap_ObjMapSpriteObject_allocate);
    rb_define_method(cObjMapSpriteObject.klass, "initialize", VALUEFUNC(_wrap_new_ObjMapSpriteObject), -1);
    rb_define_method(cObjMapSpriteObject.klass, "flip_horizontal", VALUEFUNC(_wrap_ObjMapSpriteObject_flip_horizontal), -1);
    rb_define_method(cObjMapSpriteObject.klass, "flip_vertical", VALUEFUNC(_wrap_ObjMapSpriteObject_flip_vertical), -1);
    rb_define_method(cObjMapSpriteObject.klass, "to_object", VALUEFUNC(_wrap_ObjMapSpriteObject_to_object), -1);
    cObjMapSpriteObject.mark = 0;
    cObjMapSpriteObject.destroy = (void (*)(void *)) free_ObjMapSpriteObject;
    
    cObjMapObject.klass = rb_define_class_under(mFlexlay_wrap, "ObjMapObject", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjMapObject, (void *) &cObjMapObject);
    rb_define_alloc_func(cObjMapObject.klass, _wrap_ObjMapObject_allocate);
    rb_define_method(cObjMapObject.klass, "initialize", VALUEFUNC(_wrap_new_ObjMapObject), -1);
    rb_define_method(cObjMapObject.klass, "get_pos", VALUEFUNC(_wrap_ObjMapObject_get_pos), -1);
    rb_define_method(cObjMapObject.klass, "set_pos", VALUEFUNC(_wrap_ObjMapObject_set_pos), -1);
    rb_define_method(cObjMapObject.klass, "get_metadata", VALUEFUNC(_wrap_ObjMapObject_get_metadata), -1);
    rb_define_method(cObjMapObject.klass, "set_metadata", VALUEFUNC(_wrap_ObjMapObject_set_metadata), -1);
    rb_define_method(cObjMapObject.klass, "sig_move", VALUEFUNC(_wrap_ObjMapObject_sig_move), -1);
    rb_define_method(cObjMapObject.klass, "draw", VALUEFUNC(_wrap_ObjMapObject_draw), -1);
    rb_define_method(cObjMapObject.klass, "get_bound_rect", VALUEFUNC(_wrap_ObjMapObject_get_bound_rect), -1);
    rb_define_method(cObjMapObject.klass, "is_null", VALUEFUNC(_wrap_ObjMapObject_is_null), -1);
    rb_define_method(cObjMapObject.klass, "==", VALUEFUNC(_wrap_ObjMapObject___eq__), -1);
    rb_define_method(cObjMapObject.klass, "<", VALUEFUNC(_wrap_ObjMapObject___lt__), -1);
    cObjMapObject.mark = 0;
    cObjMapObject.destroy = (void (*)(void *)) free_ObjMapObject;
    
    cZoomTool.klass = rb_define_class_under(mFlexlay_wrap, "ZoomTool", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ZoomTool, (void *) &cZoomTool);
    rb_define_alloc_func(cZoomTool.klass, _wrap_ZoomTool_allocate);
    rb_define_method(cZoomTool.klass, "initialize", VALUEFUNC(_wrap_new_ZoomTool), -1);
    rb_define_method(cZoomTool.klass, "to_tool", VALUEFUNC(_wrap_ZoomTool_to_tool), -1);
    cZoomTool.mark = 0;
    cZoomTool.destroy = (void (*)(void *)) free_ZoomTool;
    
    cGraphicContextState.klass = rb_define_class_under(mFlexlay_wrap, "GraphicContextState", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_GraphicContextState, (void *) &cGraphicContextState);
    rb_define_alloc_func(cGraphicContextState.klass, _wrap_GraphicContextState_allocate);
    rb_define_method(cGraphicContextState.klass, "initialize", VALUEFUNC(_wrap_new_GraphicContextState), -1);
    rb_define_method(cGraphicContextState.klass, "set_size", VALUEFUNC(_wrap_GraphicContextState_set_size), -1);
    rb_define_method(cGraphicContextState.klass, "push", VALUEFUNC(_wrap_GraphicContextState_push), -1);
    rb_define_method(cGraphicContextState.klass, "pop", VALUEFUNC(_wrap_GraphicContextState_pop), -1);
    rb_define_method(cGraphicContextState.klass, "get_clip_rect", VALUEFUNC(_wrap_GraphicContextState_get_clip_rect), -1);
    rb_define_method(cGraphicContextState.klass, "get_width", VALUEFUNC(_wrap_GraphicContextState_get_width), -1);
    rb_define_method(cGraphicContextState.klass, "get_height", VALUEFUNC(_wrap_GraphicContextState_get_height), -1);
    rb_define_method(cGraphicContextState.klass, "set_pos", VALUEFUNC(_wrap_GraphicContextState_set_pos), -1);
    rb_define_method(cGraphicContextState.klass, "get_pos", VALUEFUNC(_wrap_GraphicContextState_get_pos), -1);
    rb_define_method(cGraphicContextState.klass, "set_zoom", VALUEFUNC(_wrap_GraphicContextState_set_zoom), -1);
    rb_define_method(cGraphicContextState.klass, "get_zoom", VALUEFUNC(_wrap_GraphicContextState_get_zoom), -1);
    rb_define_method(cGraphicContextState.klass, "zoom_to", VALUEFUNC(_wrap_GraphicContextState_zoom_to), -1);
    rb_define_method(cGraphicContextState.klass, "screen2world", VALUEFUNC(_wrap_GraphicContextState_screen2world), -1);
    cGraphicContextState.mark = 0;
    cGraphicContextState.destroy = (void (*)(void *)) free_GraphicContextState;
    
    cObjMapPathNode.klass = rb_define_class_under(mFlexlay_wrap, "ObjMapPathNode", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_ObjMapPathNode, (void *) &cObjMapPathNode);
    rb_define_alloc_func(cObjMapPathNode.klass, _wrap_ObjMapPathNode_allocate);
    rb_define_method(cObjMapPathNode.klass, "initialize", VALUEFUNC(_wrap_new_ObjMapPathNode), -1);
    rb_define_method(cObjMapPathNode.klass, "connect", VALUEFUNC(_wrap_ObjMapPathNode_connect), -1);
    rb_define_method(cObjMapPathNode.klass, "disconnect", VALUEFUNC(_wrap_ObjMapPathNode_disconnect), -1);
    rb_define_method(cObjMapPathNode.klass, "to_object", VALUEFUNC(_wrap_ObjMapPathNode_to_object), -1);
    cObjMapPathNode.mark = 0;
    cObjMapPathNode.destroy = (void (*)(void *)) free_ObjMapPathNode;
    rb_define_module_function(mFlexlay_wrap, "load_netpanzer_tiles", VALUEFUNC(_wrap_load_netpanzer_tiles), -1);
    
    cNetPanzerFileStruct.klass = rb_define_class_under(mFlexlay_wrap, "NetPanzerFileStruct", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_NetPanzerFileStruct, (void *) &cNetPanzerFileStruct);
    rb_define_alloc_func(cNetPanzerFileStruct.klass, _wrap_NetPanzerFileStruct_allocate);
    rb_define_method(cNetPanzerFileStruct.klass, "initialize", VALUEFUNC(_wrap_new_NetPanzerFileStruct), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "get_id_header", VALUEFUNC(_wrap_NetPanzerFileStruct_get_id_header), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "get_name", VALUEFUNC(_wrap_NetPanzerFileStruct_get_name), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "get_description", VALUEFUNC(_wrap_NetPanzerFileStruct_get_description), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "get_tilemap", VALUEFUNC(_wrap_NetPanzerFileStruct_get_tilemap), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "set_id_header", VALUEFUNC(_wrap_NetPanzerFileStruct_set_id_header), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "set_name", VALUEFUNC(_wrap_NetPanzerFileStruct_set_name), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "set_description", VALUEFUNC(_wrap_NetPanzerFileStruct_set_description), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "set_tilemap", VALUEFUNC(_wrap_NetPanzerFileStruct_set_tilemap), -1);
    rb_define_method(cNetPanzerFileStruct.klass, "save", VALUEFUNC(_wrap_NetPanzerFileStruct_save), -1);
    cNetPanzerFileStruct.mark = 0;
    cNetPanzerFileStruct.destroy = (void (*)(void *)) free_NetPanzerFileStruct;
    rb_define_module_function(mFlexlay_wrap, "make_sprite", VALUEFUNC(_wrap_make_sprite), -1);
    rb_define_module_function(mFlexlay_wrap, "make_pixelbuffer", VALUEFUNC(_wrap_make_pixelbuffer), -1);
    rb_define_module_function(mFlexlay_wrap, "make_region_pixelbuffer", VALUEFUNC(_wrap_make_region_pixelbuffer), -1);
    rb_define_module_function(mFlexlay_wrap, "make_sprite_from_resource", VALUEFUNC(_wrap_make_sprite_from_resource), -1);
    rb_define_module_function(mFlexlay_wrap, "make_pixelbuffer_from_resource", VALUEFUNC(_wrap_make_pixelbuffer_from_resource), -1);
    rb_define_module_function(mFlexlay_wrap, "make_metadata", VALUEFUNC(_wrap_make_metadata), -1);
    rb_define_module_function(mFlexlay_wrap, "get_ruby_object", VALUEFUNC(_wrap_get_ruby_object), -1);
    rb_define_module_function(mFlexlay_wrap, "connect", VALUEFUNC(_wrap_connect), -1);
    rb_define_module_function(mFlexlay_wrap, "connect_v1", VALUEFUNC(_wrap_connect_v1), -1);
    rb_define_module_function(mFlexlay_wrap, "connect_v2", VALUEFUNC(_wrap_connect_v2), -1);
    rb_define_module_function(mFlexlay_wrap, "connect_v1_ObjMapObject", VALUEFUNC(_wrap_connect_v1_ObjMapObject), -1);
    rb_define_module_function(mFlexlay_wrap, "sexpr_read_from_file", VALUEFUNC(_wrap_sexpr_read_from_file), -1);
}