/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3u-20001002-1724 (Alpha 3)
 * 
 * Portions Copyright (c) 1995-2000
 * The University of Utah, The Regents of the University of California, and
 * The University of Chicago.  Permission is hereby granted to use, modify, 
 * and distribute this file in any manner provided this notice remains intact.
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */

/* $Header: /cvs/projects/SWIG/Lib/perl5/headers.swg,v 1.1 2000/01/11 21:15:51 beazley Exp $ */
/* Implementation : PERL 5 */

#define SWIGPERL
#define SWIGPERL5
#ifdef __cplusplus
/* Needed on some windows machines---since MS plays funny
   games with the header files under C++ */
#include <math.h>
#include <stdlib.h>
extern "C" {
#endif
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

/* Get rid of free and malloc defined by perl */
#undef free
#undef malloc

#include <string.h>
#ifdef __cplusplus
}
#endif
/* Definitions for compiling Perl extensions on a variety of machines */


#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
#       if defined(_MSC_VER)
#               if defined(STATIC_LINKED)
#                       define SWIGEXPORT(a) a
#               else
#                       define SWIGEXPORT(a) __declspec(dllexport) a
#               endif
#       else
#               if defined(__BORLANDC__)
#                       define SWIGEXPORT(a) a _export
#               else
#                       define SWIGEXPORT(a) a
#       endif
#endif
#else
#       define SWIGEXPORT(a) a
#endif

#ifdef PERL_OBJECT
#define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
#define MAGIC_CAST   (int (CPerlObj::*)(SV *, MAGIC *))
#define SWIGCLASS_STATIC 
#else
#define MAGIC_PPERL
#define MAGIC_CAST
#define SWIGCLASS_STATIC static
#endif

#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
#endif

/* Modifications for newer Perl 5.005 releases */

#if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
#ifndef PL_sv_yes
#define PL_sv_yes sv_yes
#endif
#ifndef PL_sv_undef
#define PL_sv_undef sv_undef
#endif
#ifndef PL_na
#define PL_na na
#endif
#endif

/******************************************************************************
 * Pointer type-checking code
 *****************************************************************************/

#include <stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef SWIG_NOINCLUDE
extern void SWIG_MakePtr(char *, void *, char *);
#ifndef PERL_OBJECT
extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
#else
#define SWIG_RegisterMapping(a,b,c) _SWIG_RegisterMapping(pPerl,a,b,c);
extern void _SWIG_RegisterMapping(CPerlObj *,char *, char *, void *(*)(void *),int);
#endif
#ifndef PERL_OBJECT
extern char *SWIG_GetPtr(SV *, void **, char *);
#else
extern char *_SWIG_GetPtr(CPerlObj *, SV *, void **, char *);
#define SWIG_GetPtr(a,b,c) _SWIG_GetPtr(pPerl,a,b,c)
#endif

#else

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

/* These are internal variables.   Should be static */

typedef struct SwigPtrType {
  char               *name;
  int                 len;
  void               *(*cast)(void *);
  struct SwigPtrType *next;
} SwigPtrType;

/* Pointer cache structure */

typedef struct {
  int                 stat;               /* Status (valid) bit             */
  SwigPtrType        *tp;                 /* Pointer to type structure      */
  char                name[256];          /* Given datatype name            */
  char                mapped[256];        /* Equivalent name                */
} SwigCacheType;

static int SwigPtrMax  = 64;           /* Max entries that can be currently held */
static int SwigPtrN    = 0;            /* Current number of entries              */
static int SwigPtrSort = 0;            /* Status flag indicating sort            */
static SwigPtrType *SwigPtrTable = 0;  /* Table containing pointer equivalences  */
static int SwigStart[256];             /* Table containing starting positions    */

/* Cached values */

#define SWIG_CACHESIZE  8
#define SWIG_CACHEMASK  0x7
static SwigCacheType SwigCache[SWIG_CACHESIZE];  
static int SwigCacheIndex = 0;
static int SwigLastCache = 0;

/* Sort comparison function */
static int swigsort(const void *data1, const void *data2) {
	SwigPtrType *d1 = (SwigPtrType *) data1;
	SwigPtrType *d2 = (SwigPtrType *) data2;
	return strcmp(d1->name,d2->name);
}

/* Binary Search function */
static int swigcmp(const void *key, const void *data) {
  char *k = (char *) key;
  SwigPtrType *d = (SwigPtrType *) data;
  return strncmp(k,d->name,d->len);
}

/* Register a new datatype with the type-checker */

#ifndef PERL_OBJECT
SWIGSTATICRUNTIME(void) 
SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *)) {
#else
#define SWIG_RegisterMapping(a,b,c) _SWIG_RegisterMapping(pPerl, a,b,c)
SWIGSTATICRUNTIME(void)
_SWIG_RegisterMapping(CPerlObj *pPerl, char *origtype, char *newtype, void *(*cast)(void *)) {
#endif

  int i;
  SwigPtrType *t = 0, *t1;

  if (!SwigPtrTable) {     
    SwigPtrTable = (SwigPtrType *) malloc(SwigPtrMax*sizeof(SwigPtrType));
    SwigPtrN = 0;
  }
  if (SwigPtrN >= SwigPtrMax) {
    SwigPtrMax = 2*SwigPtrMax;
    SwigPtrTable = (SwigPtrType *) realloc(SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
  }
  for (i = 0; i < SwigPtrN; i++)
    if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
      t = &SwigPtrTable[i];
      break;
    }
  if (!t) {
    t = &SwigPtrTable[SwigPtrN];
    t->name = origtype;
    t->len = strlen(t->name);
    t->cast = 0;
    t->next = 0;
    SwigPtrN++;
  }
  while (t->next) {
    if (strcmp(t->name,newtype) == 0) {
      if (cast) t->cast = cast;
      return;
    }
    t = t->next;
  }
  t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
  t1->name = newtype;
  t1->len = strlen(t1->name);
  t1->cast = cast;
  t1->next = 0;
  t->next = t1;
  SwigPtrSort = 0;
}

/* Make a pointer value string */

SWIGSTATICRUNTIME(void) 
SWIG_MakePtr(char *_c, const void *_ptr, char *type) {
  static char _hex[16] =
  {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
   'a', 'b', 'c', 'd', 'e', 'f'};
  unsigned long _p, _s;
  char _result[20], *_r;    /* Note : a 64-bit hex number = 16 digits */
  _r = _result;
  _p = (unsigned long) _ptr;
  if (_p > 0) {
    while (_p > 0) {
      _s = _p & 0xf;
      *(_r++) = _hex[_s];
      _p = _p >> 4;
    }
    *_r = '_';
    while (_r >= _result)
      *(_c++) = *(_r--);
  } else {
    strcpy (_c, "NULL");
  }
  if (_ptr)
    strcpy (_c, type);
}

/* Function for getting a pointer value */

#ifndef PERL_OBJECT
SWIGSTATICRUNTIME(char *) 
SWIG_GetPtr(SV *sv, void **ptr, char *_t)
#else
#define SWIG_GetPtr(a,b,c) _SWIG_GetPtr(pPerl,a,b,c)
SWIGSTATICRUNTIME(char *)
_SWIG_GetPtr(CPerlObj *pPerl, SV *sv, void **ptr, char *_t)
#endif
{
  char temp_type[256];
  char *name,*_c;
  int  len,i,start,end;
  IV   tmp;
  SwigPtrType *sp,*tp;
  SwigCacheType *cache;

  /* If magical, apply more magic */

  if (SvGMAGICAL(sv))
    mg_get(sv);

  /* Check to see if this is an object */
  if (sv_isobject(sv)) {
    SV *tsv = (SV*) SvRV(sv);
    if ((SvTYPE(tsv) == SVt_PVHV)) {
      MAGIC *mg;
      if (SvMAGICAL(tsv)) {
	mg = mg_find(tsv,'P');
	if (mg) {
	  SV *rsv = mg->mg_obj;
	  if (sv_isobject(rsv)) {
	    tmp = SvIV((SV*)SvRV(rsv));
	  }
	}
      } else {
	return "Not a valid pointer value";
      }
    } else {
      tmp = SvIV((SV*)SvRV(sv));
    }
    if (!_t) {
      *(ptr) = (void *) tmp;
      return (char *) 0;
    }
  } else if (! SvOK(sv)) {            /* Check for undef */
    *(ptr) = (void *) 0;
    return (char *) 0;
  } else if (SvTYPE(sv) == SVt_RV) {       /* Check for NULL pointer */
    *(ptr) = (void *) 0;
    if (!SvROK(sv)) 
      return (char *) 0;
    else
      return "Not a valid pointer value";
  } else {                                 /* Don't know what it is */
      *(ptr) = (void *) 0;
      return "Not a valid pointer value";
  }
  if (_t) {
    /* Now see if the types match */      

    if (!sv_isa(sv,_t)) {
      _c = HvNAME(SvSTASH(SvRV(sv)));
      if (!SwigPtrSort) {
	qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);  
	for (i = 0; i < 256; i++) {
	  SwigStart[i] = SwigPtrN;
	}
	for (i = SwigPtrN-1; i >= 0; i--) {
	  SwigStart[SwigPtrTable[i].name[0]] = i;
	}
	for (i = 255; i >= 1; i--) {
	  if (SwigStart[i-1] > SwigStart[i])
	    SwigStart[i-1] = SwigStart[i];
	}
	SwigPtrSort = 1;
	for (i = 0; i < SWIG_CACHESIZE; i++)  
	  SwigCache[i].stat = 0;
      }
      /* First check cache for matches.  Uses last cache value as starting point */
      cache = &SwigCache[SwigLastCache];
      for (i = 0; i < SWIG_CACHESIZE; i++) {
	if (cache->stat) {
	  if (strcmp(_t,cache->name) == 0) {
	    if (strcmp(_c,cache->mapped) == 0) {
	      cache->stat++;
	      *ptr = (void *) tmp;
	      if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr);
	      return (char *) 0;
	    }
	  }
	}
	SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
	if (!SwigLastCache) cache = SwigCache;
	else cache++;
      }

      start = SwigStart[_t[0]];
      end = SwigStart[_t[0]+1];
      sp = &SwigPtrTable[start];
      while (start < end) {
	if (swigcmp(_t,sp) == 0) break;
	sp++;
	start++;
      }
      if (start > end) sp = 0;
      while (start <= end) {
	if (swigcmp(_t,sp) == 0) {
	  name = sp->name;
	  len = sp->len;
	  tp = sp->next;
	  while(tp) {
	    if (tp->len >= 255) {
	      return _c;
	    }
	    strcpy(temp_type,tp->name);
	    strncat(temp_type,_t+len,255-tp->len);
	    if (sv_isa(sv,temp_type)) {
	      /* Get pointer value */
	      *ptr = (void *) tmp;
	      if (tp->cast) *ptr = (*(tp->cast))(*ptr);

	      strcpy(SwigCache[SwigCacheIndex].mapped,_c);
	      strcpy(SwigCache[SwigCacheIndex].name,_t);
	      SwigCache[SwigCacheIndex].stat = 1;
	      SwigCache[SwigCacheIndex].tp = tp;
	      SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
	      return (char *) 0;
	    }
	    tp = tp->next;
	  } 
	}
	sp++;
	start++;
      }
      /* Didn't find any sort of match for this data.  
	 Get the pointer value and return the received type */
      *ptr = (void *) tmp;
      return _c;
    } else {
      /* Found a match on the first try.  Return pointer value */
      *ptr = (void *) tmp;
      return (char *) 0;
    }
  } 
  *ptr = (void *) tmp;
  return (char *) 0;
}

#endif
#ifdef __cplusplus
}
#endif






/* Magic variable code */
#ifndef PERL_OBJECT
#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
#else
#define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
static void _swig_create_magic(CPerlObj *pPerl, SV *sv, char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
#endif
  MAGIC *mg;
  sv_magic(sv,sv,'U',name,strlen(name));
  mg = mg_find(sv,'U');
  mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
  mg->mg_virtual->svt_get = get;
  mg->mg_virtual->svt_set = set;
  mg->mg_virtual->svt_len = 0;
  mg->mg_virtual->svt_clear = 0;
  mg->mg_virtual->svt_free = 0;
}

#define SWIG_init    boot_GFL

#define SWIG_name   "GFLc::boot_GFL"
#define SWIG_varinit "GFLc::var_GFL_init();"
#ifdef __cplusplus
extern "C"
#endif
#ifndef PERL_OBJECT
SWIGEXPORT(void) SWIG_init (CV* cv);
#else
SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
#endif

#include "libgfl.h"
GFL_RECT *new_Rect (GFL_INT32 x,GFL_INT32 y,GFL_INT32 w,GFL_INT32 h);
typedef unsigned long GFL_MEMALLOC;
void free_GflStruct(GFL_MEMALLOC *ptr);
#ifndef PERL_OBJECT
#define swig_setpv(a,b) _swig_setpv(a,b)
static void _swig_setpv(char *name, char *value) { 
#else
#define swig_setpv(a,b) _swig_setpv(pPerl,a,b)
static void _swig_setpv(CPerlObj *pPerl, char *name, char *value) { 
#endif
     SV *sv; 
     sv = perl_get_sv(name,TRUE | 0x2);
     sv_setpv(sv, value);
     SvREADONLY_on(sv);
}

#ifndef PERL_OBJECT
#define swig_setiv(a,b) _swig_setiv(a,b)
static void _swig_setiv(char *name, long value) { 
#else
#define swig_setiv(a,b) _swig_setiv(pPerl,a,b)
static void _swig_setiv(CPerlObj *pPerl, char *name, long value) { 
#endif
     SV *sv; 
     sv = perl_get_sv(name,TRUE | 0x2);
     sv_setiv(sv, (IV) value);
     SvREADONLY_on(sv);
}


typedef struct {
				GFL_READ_CALLBACK  Read; 
				GFL_TELL_CALLBACK  Tell; 
				GFL_SEEK_CALLBACK  Seek; 

				GFL_ALLOC_CALLBACK Alloc; /* Not yet implemented */
				GFL_FREE_CALLBACK  Free;  /* Not yet implemented */
				void * AllocParam; 
			} GFL_LOAD_PARAMS_Callbacks;


typedef struct {
				GFL_WRITE_CALLBACK Write; /* Not yet implemented */
				GFL_TELL_CALLBACK  Tell;  /* Not yet implemented */
				GFL_SEEK_CALLBACK  Seek;  /* Not yet implemented */

				GFL_ALLOC_CALLBACK Alloc; /* Not yet implemented */
				GFL_FREE_CALLBACK  Free;  /* Not yet implemented */
				void * AllocParam; 
			} GFL_SAVE_PARAMS_Callbacks;

extern void *gflMemoryAlloc(GFL_UINT32 );
extern void *gflMemoryRealloc(void *,GFL_UINT32 );
extern void gflMemoryFree(void *);
extern const char *gflGetVersion();
extern const char *gflGetVersionOfLibformat();
extern GFL_ERROR gflLibraryInit();
extern void gflLibraryExit();
extern void gflEnableLZW(GFL_BOOL );
extern GFL_INT32 gflGetNumberOfFormat();
extern GFL_INT32 gflGetFormatIndexByName(const char *);
extern const char *gflGetFormatNameByIndex(GFL_INT32 );
extern GFL_BOOL gflFormatIsSupported(const char *);
extern GFL_BOOL gflFormatIsWritableByIndex(GFL_INT32 );
extern GFL_BOOL gflFormatIsWritableByName(const char *);
extern GFL_BOOL gflFormatIsReadableByIndex(GFL_INT32 );
extern GFL_BOOL gflFormatIsReadableByName(const char *);
extern const char *gflGetDefaultFormatSuffixByIndex(GFL_INT32 );
extern const char *gflGetDefaultFormatSuffixByName(const char *);
extern const char *gflGetFormatDescriptionByIndex(GFL_INT32 );
extern const char *gflGetFormatDescriptionByName(const char *);
extern GFL_ERROR gflGetFormatInformationByName(const char *,GFL_FORMAT_INFORMATION *);
extern GFL_ERROR gflGetFormatInformationByIndex(GFL_INT32 ,GFL_FORMAT_INFORMATION *);
extern const char *gflGetErrorString(GFL_ERROR );
extern GFL_ERROR gflGetFileInformation(const char *,GFL_INT32 ,GFL_FILE_INFORMATION *);
extern void gflGetDefaultLoadParams(GFL_LOAD_PARAMS *);
extern GFL_ERROR gflLoadBitmap(const char *,GFL_BITMAP **,GFL_LOAD_PARAMS *,GFL_FILE_INFORMATION *);
extern GFL_ERROR gflLoadBitmapFromHandle(GFL_HANDLE ,GFL_BITMAP **,GFL_LOAD_PARAMS *,GFL_FILE_INFORMATION *);
extern void gflGetDefaultPreviewParams(GFL_LOAD_PARAMS *);
extern GFL_ERROR gflLoadPreview(const char *,GFL_INT32 ,GFL_INT32 ,GFL_BITMAP **,GFL_LOAD_PARAMS *,GFL_FILE_INFORMATION *);
extern GFL_ERROR gflLoadPreviewFromHandle(GFL_HANDLE ,GFL_INT32 ,GFL_INT32 ,GFL_BITMAP **,GFL_LOAD_PARAMS *,GFL_FILE_INFORMATION *);
extern void gflGetDefaultSaveParams(GFL_SAVE_PARAMS *);
extern GFL_ERROR gflSaveBitmap(char *,GFL_BITMAP *,GFL_SAVE_PARAMS *);
extern GFL_ERROR gflSaveBitmapFromHandle(GFL_HANDLE ,GFL_BITMAP *,GFL_SAVE_PARAMS *);
extern GFL_BITMAP *gflAllockBitmap(GFL_BITMAP_TYPE ,GFL_INT32 ,GFL_INT32 ,GFL_UINT32 );
extern void gflFreeBitmap(GFL_BITMAP *);
extern void gflFreeBitmapData(GFL_BITMAP *);
extern GFL_ERROR gflResize(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 ,GFL_INT32 ,GFL_UINT32 ,GFL_UINT32 );
extern GFL_ERROR gflChangeColorDepth(GFL_BITMAP *,GFL_BITMAP **,GFL_MODE ,GFL_MODE_PARAMS );
extern GFL_ERROR gflFlipVertical(GFL_BITMAP *,GFL_BITMAP **);
extern GFL_ERROR gflFlipHorizontal(GFL_BITMAP *,GFL_BITMAP **);
extern GFL_ERROR gflCrop(GFL_BITMAP *,GFL_BITMAP **,const GFL_RECT *);
extern GFL_ERROR gflNegative(GFL_BITMAP *,GFL_BITMAP **);
extern GFL_ERROR gflBrightness(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflContrast(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflGamma(GFL_BITMAP *,GFL_BITMAP **,double );
extern GFL_ERROR gflRotate(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflAverage(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflSoften(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflBlur(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflGaussianBlur(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflMaximum(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflMinimum(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflMedianBox(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflMedianCross(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_ERROR gflSharpen(GFL_BITMAP *,GFL_BITMAP **,GFL_INT32 );
extern GFL_UINT32 gflGetNumberOfColorsUsed(GFL_BITMAP *);


void free_GflStruct(GFL_MEMALLOC *ptr)
{
	gflMemoryFree((void *)ptr);
}

GFL_FILE_INFORMATION *new_FileInformation()
{
	return (GFL_FILE_INFORMATION *)gflMemoryAlloc(sizeof(GFL_FILE_INFORMATION));
}
GFL_FORMAT_INFORMATION *new_FormatInformation()
{
	return (GFL_FORMAT_INFORMATION *)gflMemoryAlloc(sizeof(GFL_FORMAT_INFORMATION));
}

GFL_LOAD_PARAMS *new_LoadParams()
{
	return (GFL_LOAD_PARAMS *)gflMemoryAlloc(sizeof(GFL_LOAD_PARAMS));
}

GFL_SAVE_PARAMS *new_SaveParams()
{
	return (GFL_SAVE_PARAMS *)gflMemoryAlloc(sizeof(GFL_SAVE_PARAMS));
}

GFL_RECT *new_Rect (GFL_INT32 x,GFL_INT32 y,GFL_INT32 w,GFL_INT32 h)
{
	GFL_RECT rect;
	GFL_RECT *rectPtr;
	rect.x = x;
	rect.y = y;
	rect.w = w;
	rect.h = h;
	rectPtr = (GFL_RECT *)gflMemoryAlloc(sizeof(GFL_RECT));
	return (GFL_RECT *)memmove( rectPtr, &rect, sizeof(GFL_RECT));
}

GFL_BITMAP **new_BitmapPtr()
{
	return (GFL_BITMAP **)gflMemoryAlloc(sizeof(GFL_BITMAP *));
}

GFL_BITMAP *addr_of_Bitmap(GFL_BITMAP **bitmap)
{
	return *bitmap;
}

#ifdef PERL_OBJECT
#define MAGIC_CLASS _wrap_GFL_var::
class _wrap_GFL_var : public CPerlObj {
public:
#else
#define MAGIC_CLASS
#endif
SWIGCLASS_STATIC int swig_magic_readonly(SV *sv, MAGIC *mg) {
    MAGIC_PPERL
    sv = sv; mg = mg;
    croak("Value is read-only.");
    return 0;
}


#ifdef PERL_OBJECT
};
#endif

XS(_wrap_gflMemoryAlloc) {

    void  *_result;
    GFL_UINT32  _arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflMemoryAlloc(size);");
    _arg0 = (GFL_UINT32 )SvIV(ST(0));
    _result = (void *)gflMemoryAlloc(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"voidPtr", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflMemoryRealloc) {

    void  *_result,*_arg0;
    GFL_UINT32  _arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: gflMemoryRealloc(ptr,size);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
        croak("Type error in argument 1 of gflMemoryRealloc. Expected voidPtr.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (void *)gflMemoryRealloc(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"voidPtr", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflMemoryFree) {

    void  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflMemoryFree(ptr);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
        croak("Type error in argument 1 of gflMemoryFree. Expected voidPtr.");
        XSRETURN(1);
    }
    gflMemoryFree(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_gflGetVersion) {

    int argvi = 0;
    dXSARGS ;
    char  *_result;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: gflGetVersion();");
    _result = (char *)gflGetVersion();
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetVersionOfLibformat) {

    int argvi = 0;
    dXSARGS ;
    char  *_result;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: gflGetVersionOfLibformat();");
    _result = (char *)gflGetVersionOfLibformat();
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflLibraryInit) {

    GFL_ERROR  _result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: gflLibraryInit();");
    _result = (GFL_ERROR )gflLibraryInit();
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflLibraryExit) {

    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: gflLibraryExit();");
    gflLibraryExit();
    XSRETURN(argvi);
}

XS(_wrap_gflEnableLZW) {

    GFL_BOOL  _arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflEnableLZW(GFL_BOOL );");
    _arg0 = (GFL_BOOL )SvIV(ST(0));
    gflEnableLZW(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_gflGetNumberOfFormat) {

    GFL_INT32  _result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: gflGetNumberOfFormat();");
    _result = (GFL_INT32 )gflGetNumberOfFormat();
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetFormatIndexByName) {

    GFL_INT32  _result;
    int argvi = 0;
    dXSARGS ;
    char  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetFormatIndexByName(name);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _result = (GFL_INT32 )gflGetFormatIndexByName(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetFormatNameByIndex) {

    GFL_INT32  _arg0;
    int argvi = 0;
    dXSARGS ;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetFormatNameByIndex(index);");
    _arg0 = (GFL_INT32 )SvIV(ST(0));
    _result = (char *)gflGetFormatNameByIndex(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFormatIsSupported) {

    GFL_BOOL  _result;
    int argvi = 0;
    dXSARGS ;
    char  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflFormatIsSupported(name);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _result = (GFL_BOOL )gflFormatIsSupported(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFormatIsWritableByIndex) {

    GFL_INT32  _arg0;
    GFL_BOOL  _result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflFormatIsWritableByIndex(index);");
    _arg0 = (GFL_INT32 )SvIV(ST(0));
    _result = (GFL_BOOL )gflFormatIsWritableByIndex(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFormatIsWritableByName) {

    GFL_BOOL  _result;
    int argvi = 0;
    dXSARGS ;
    char  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflFormatIsWritableByName(name);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _result = (GFL_BOOL )gflFormatIsWritableByName(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFormatIsReadableByIndex) {

    GFL_INT32  _arg0;
    GFL_BOOL  _result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflFormatIsReadableByIndex(index);");
    _arg0 = (GFL_INT32 )SvIV(ST(0));
    _result = (GFL_BOOL )gflFormatIsReadableByIndex(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFormatIsReadableByName) {

    GFL_BOOL  _result;
    int argvi = 0;
    dXSARGS ;
    char  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflFormatIsReadableByName(name);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _result = (GFL_BOOL )gflFormatIsReadableByName(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetDefaultFormatSuffixByIndex) {

    GFL_INT32  _arg0;
    int argvi = 0;
    dXSARGS ;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetDefaultFormatSuffixByIndex(index);");
    _arg0 = (GFL_INT32 )SvIV(ST(0));
    _result = (char *)gflGetDefaultFormatSuffixByIndex(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetDefaultFormatSuffixByName) {

    int argvi = 0;
    dXSARGS ;
    char  *_result,*_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetDefaultFormatSuffixByName(name);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _result = (char *)gflGetDefaultFormatSuffixByName(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetFormatDescriptionByIndex) {

    GFL_INT32  _arg0;
    int argvi = 0;
    dXSARGS ;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetFormatDescriptionByIndex(index);");
    _arg0 = (GFL_INT32 )SvIV(ST(0));
    _result = (char *)gflGetFormatDescriptionByIndex(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetFormatDescriptionByName) {

    int argvi = 0;
    dXSARGS ;
    char  *_result,*_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetFormatDescriptionByName(name);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _result = (char *)gflGetFormatDescriptionByName(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetFormatInformationByName) {

    GFL_ERROR  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg1;
    char  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: gflGetFormatInformationByName(name,info);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 2 of gflGetFormatInformationByName. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflGetFormatInformationByName(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetFormatInformationByIndex) {

    GFL_INT32  _arg0;
    GFL_ERROR  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: gflGetFormatInformationByIndex(index,info);");
    _arg0 = (GFL_INT32 )SvIV(ST(0));
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 2 of gflGetFormatInformationByIndex. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflGetFormatInformationByIndex(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetErrorString) {

    GFL_ERROR  _arg0;
    int argvi = 0;
    dXSARGS ;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetErrorString(error);");
    _arg0 = (GFL_ERROR )SvIV(ST(0));
    _result = (char *)gflGetErrorString(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetFileInformation) {

    GFL_INT32  _arg1;
    GFL_ERROR  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg2;
    char  *_arg0;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflGetFileInformation(filename,index,info);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    if (SWIG_GetPtr(ST(2),(void **) &_arg2,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 3 of gflGetFileInformation. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflGetFileInformation(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetDefaultLoadParams) {

    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetDefaultLoadParams(params);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of gflGetDefaultLoadParams. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    gflGetDefaultLoadParams(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_gflLoadBitmap) {

    GFL_ERROR  _result;
    GFL_BITMAP  **_arg1;
    GFL_LOAD_PARAMS  *_arg2;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg3;
    char  *_arg0;
    cv = cv;
    if ((items < 4) || (items > 4)) 
        croak("Usage: gflLoadBitmap(filename,bitmap,params,info);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflLoadBitmap. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(2),(void **) &_arg2,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 3 of gflLoadBitmap. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(3),(void **) &_arg3,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 4 of gflLoadBitmap. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflLoadBitmap(_arg0,_arg1,_arg2,_arg3);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflLoadBitmapFromHandle) {

    GFL_ERROR  _result;
    GFL_HANDLE  _arg0;
    GFL_BITMAP  **_arg1;
    GFL_LOAD_PARAMS  *_arg2;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg3;
    cv = cv;
    if ((items < 4) || (items > 4)) 
        croak("Usage: gflLoadBitmapFromHandle(handle,bitmap,params,info);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
        croak("Type error in argument 1 of gflLoadBitmapFromHandle. Expected GFL_HANDLE.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflLoadBitmapFromHandle. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(2),(void **) &_arg2,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 3 of gflLoadBitmapFromHandle. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(3),(void **) &_arg3,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 4 of gflLoadBitmapFromHandle. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflLoadBitmapFromHandle(_arg0,_arg1,_arg2,_arg3);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetDefaultPreviewParams) {

    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetDefaultPreviewParams(params);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of gflGetDefaultPreviewParams. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    gflGetDefaultPreviewParams(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_gflLoadPreview) {

    GFL_INT32  _arg1,_arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  **_arg3;
    GFL_LOAD_PARAMS  *_arg4;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg5;
    char  *_arg0;
    cv = cv;
    if ((items < 6) || (items > 6)) 
        croak("Usage: gflLoadPreview(filename,width,height,bitmap,params,info);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    if (SWIG_GetPtr(ST(3),(void **) &_arg3,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 4 of gflLoadPreview. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(4),(void **) &_arg4,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 5 of gflLoadPreview. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(5),(void **) &_arg5,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 6 of gflLoadPreview. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflLoadPreview(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflLoadPreviewFromHandle) {

    GFL_INT32  _arg1,_arg2;
    GFL_ERROR  _result;
    GFL_HANDLE  _arg0;
    GFL_BITMAP  **_arg3;
    GFL_LOAD_PARAMS  *_arg4;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg5;
    cv = cv;
    if ((items < 6) || (items > 6)) 
        croak("Usage: gflLoadPreviewFromHandle(handle,width,height,bitmap,params,info);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
        croak("Type error in argument 1 of gflLoadPreviewFromHandle. Expected GFL_HANDLE.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    if (SWIG_GetPtr(ST(3),(void **) &_arg3,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 4 of gflLoadPreviewFromHandle. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(4),(void **) &_arg4,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 5 of gflLoadPreviewFromHandle. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(5),(void **) &_arg5,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 6 of gflLoadPreviewFromHandle. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflLoadPreviewFromHandle(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetDefaultSaveParams) {

    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetDefaultSaveParams(params);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of gflGetDefaultSaveParams. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    gflGetDefaultSaveParams(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_gflSaveBitmap) {

    GFL_ERROR  _result;
    GFL_BITMAP  *_arg1;
    GFL_SAVE_PARAMS  *_arg2;
    int argvi = 0;
    dXSARGS ;
    char  *_arg0;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflSaveBitmap(filename,bitmap,params);");
    if (! SvOK((SV*) ST(0))) { _arg0 = 0; }
    else { _arg0 = (char *) SvPV(ST(0),PL_na); }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAP")) {
        croak("Type error in argument 2 of gflSaveBitmap. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(2),(void **) &_arg2,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 3 of gflSaveBitmap. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflSaveBitmap(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflSaveBitmapFromHandle) {

    GFL_ERROR  _result;
    GFL_HANDLE  _arg0;
    GFL_BITMAP  *_arg1;
    GFL_SAVE_PARAMS  *_arg2;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflSaveBitmapFromHandle(handle,bitmap,params);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
        croak("Type error in argument 1 of gflSaveBitmapFromHandle. Expected GFL_HANDLE.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAP")) {
        croak("Type error in argument 2 of gflSaveBitmapFromHandle. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(2),(void **) &_arg2,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 3 of gflSaveBitmapFromHandle. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflSaveBitmapFromHandle(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflAllockBitmap) {

    GFL_INT32  _arg1,_arg2;
    GFL_UINT32  _arg3;
    GFL_BITMAP  *_result;
    GFL_BITMAP_TYPE  _arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 4) || (items > 4)) 
        croak("Usage: gflAllockBitmap(type,width,height,line_padding);");
    _arg0 = (GFL_BITMAP_TYPE )SvIV(ST(0));
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _arg3 = (GFL_UINT32 )SvIV(ST(3));
    _result = (GFL_BITMAP *)gflAllockBitmap(_arg0,_arg1,_arg2,_arg3);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_BITMAP", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFreeBitmap) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflFreeBitmap(bitmap);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflFreeBitmap. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    gflFreeBitmap(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_gflFreeBitmapData) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflFreeBitmapData(bitmap);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflFreeBitmapData. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    gflFreeBitmapData(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_gflResize) {

    GFL_INT32  _arg2,_arg3;
    GFL_UINT32  _arg4,_arg5;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 6) || (items > 6)) 
        croak("Usage: gflResize(src,dst,width,height,method,flags);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflResize. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflResize. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _arg3 = (GFL_INT32 )SvIV(ST(3));
    _arg4 = (GFL_UINT32 )SvIV(ST(4));
    _arg5 = (GFL_UINT32 )SvIV(ST(5));
    _result = (GFL_ERROR )gflResize(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflChangeColorDepth) {

    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    GFL_MODE_PARAMS  _arg3;
    int argvi = 0;
    dXSARGS ;
    GFL_MODE  _arg2;
    cv = cv;
    if ((items < 4) || (items > 4)) 
        croak("Usage: gflChangeColorDepth(src,dst,mode,params);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflChangeColorDepth. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflChangeColorDepth. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_MODE )SvIV(ST(2));
    _arg3 = (GFL_MODE_PARAMS )SvIV(ST(3));
    _result = (GFL_ERROR )gflChangeColorDepth(_arg0,_arg1,_arg2,_arg3);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFlipVertical) {

    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: gflFlipVertical(src,dst);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflFlipVertical. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflFlipVertical. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflFlipVertical(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflFlipHorizontal) {

    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: gflFlipHorizontal(src,dst);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflFlipHorizontal. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflFlipHorizontal. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflFlipHorizontal(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflCrop) {

    GFL_ERROR  _result;
    GFL_RECT  *_arg2;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflCrop(src,dst,rect);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflCrop. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflCrop. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(2),(void **) &_arg2,"GFL_RECT")) {
        croak("Type error in argument 3 of gflCrop. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflCrop(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflNegative) {

    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: gflNegative(src,dst);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflNegative. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflNegative. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _result = (GFL_ERROR )gflNegative(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflBrightness) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflBrightness(src,dst,brightness);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflBrightness. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflBrightness. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflBrightness(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflContrast) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflContrast(src,dst,contrast);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflContrast. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflContrast. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflContrast(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGamma) {

    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    double  _arg2;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflGamma(src,dst,gamma);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflGamma. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflGamma. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (double ) SvNV(ST(2));
    _result = (GFL_ERROR )gflGamma(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflRotate) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflRotate(src,dst,angle);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflRotate. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflRotate. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflRotate(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflAverage) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflAverage(src,dst,filter_size);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflAverage. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflAverage. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflAverage(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflSoften) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflSoften(src,dst,percentage);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflSoften. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflSoften. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflSoften(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflBlur) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflBlur(src,dst,percentage);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflBlur. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflBlur. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflBlur(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGaussianBlur) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflGaussianBlur(src,dst,filter_size);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflGaussianBlur. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflGaussianBlur. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflGaussianBlur(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflMaximum) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflMaximum(src,dst,filter_size);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflMaximum. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflMaximum. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflMaximum(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflMinimum) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflMinimum(src,dst,filter_size);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflMinimum. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflMinimum. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflMinimum(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflMedianBox) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflMedianBox(src,dst,filter_size);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflMedianBox. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflMedianBox. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflMedianBox(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflMedianCross) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflMedianCross(src,dst,filter_size);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflMedianCross. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflMedianCross. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflMedianCross(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflSharpen) {

    GFL_INT32  _arg2;
    GFL_ERROR  _result;
    GFL_BITMAP  *_arg0,**_arg1;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 3) || (items > 3)) 
        croak("Usage: gflSharpen(src,dst,percentage);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflSharpen. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 2 of gflSharpen. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _result = (GFL_ERROR )gflSharpen(_arg0,_arg1,_arg2);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_gflGetNumberOfColorsUsed) {

    GFL_UINT32  _result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: gflGetNumberOfColorsUsed(GFL_BITMAP *);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of gflGetNumberOfColorsUsed. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )gflGetNumberOfColorsUsed(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

XS(_wrap_free_GflStruct) {

    GFL_MEMALLOC  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: free_GflStruct(ptr);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_MEMALLOCPtr")) {
        croak("Type error in argument 1 of free_GflStruct. Expected GFL_MEMALLOCPtr.");
        XSRETURN(1);
    }
    free_GflStruct(_arg0);
    XSRETURN(argvi);
}

XS(_wrap_new_FileInformation) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_result;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: new_FileInformation();");
    _result = (GFL_FILE_INFORMATION *)new_FileInformation();
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_FILE_INFORMATION", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_new_FormatInformation) {

    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_result;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: new_FormatInformation();");
    _result = (GFL_FORMAT_INFORMATION *)new_FormatInformation();
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_FORMAT_INFORMATION", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_new_LoadParams) {

    GFL_LOAD_PARAMS  *_result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: new_LoadParams();");
    _result = (GFL_LOAD_PARAMS *)new_LoadParams();
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_LOAD_PARAMS", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_new_SaveParams) {

    GFL_SAVE_PARAMS  *_result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: new_SaveParams();");
    _result = (GFL_SAVE_PARAMS *)new_SaveParams();
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_SAVE_PARAMS", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_new_Rect) {

    GFL_INT32  _arg0,_arg1,_arg2,_arg3;
    GFL_RECT  *_result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 4) || (items > 4)) 
        croak("Usage: new_Rect(x,y,w,h);");
    _arg0 = (GFL_INT32 )SvIV(ST(0));
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _arg2 = (GFL_INT32 )SvIV(ST(2));
    _arg3 = (GFL_INT32 )SvIV(ST(3));
    _result = (GFL_RECT *)new_Rect(_arg0,_arg1,_arg2,_arg3);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_RECT", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_new_BitmapPtr) {

    GFL_BITMAP  **_result;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 0) || (items > 0)) 
        croak("Usage: new_BitmapPtr();");
    _result = (GFL_BITMAP **)new_BitmapPtr();
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_BITMAPPtrPtr", (void *) _result);
    XSRETURN(argvi);
}

XS(_wrap_addr_of_Bitmap) {

    GFL_BITMAP  *_result,**_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: addr_of_Bitmap(bitmap);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAPPtrPtr")) {
        croak("Type error in argument 1 of addr_of_Bitmap. Expected GFL_BITMAPPtrPtr.");
        XSRETURN(1);
    }
    _result = (GFL_BITMAP *)addr_of_Bitmap(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_BITMAP", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_COLORMAP_Red_get(_swigobj) ((GFL_UINT8 *) _swigobj->Red)
XS(_wrap_GFL_COLORMAP_Red_get) {

    GFL_COLORMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_COLORMAP_Red_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_COLORMAP")) {
        croak("Type error in argument 1 of GFL_COLORMAP_Red_get. Expected GFL_COLORMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT8 *)GFL_COLORMAP_Red_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_UINT8Ptr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_COLORMAP_Green_get(_swigobj) ((GFL_UINT8 *) _swigobj->Green)
XS(_wrap_GFL_COLORMAP_Green_get) {

    GFL_COLORMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_COLORMAP_Green_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_COLORMAP")) {
        croak("Type error in argument 1 of GFL_COLORMAP_Green_get. Expected GFL_COLORMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT8 *)GFL_COLORMAP_Green_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_UINT8Ptr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_COLORMAP_Blue_get(_swigobj) ((GFL_UINT8 *) _swigobj->Blue)
XS(_wrap_GFL_COLORMAP_Blue_get) {

    GFL_COLORMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_COLORMAP_Blue_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_COLORMAP")) {
        croak("Type error in argument 1 of GFL_COLORMAP_Blue_get. Expected GFL_COLORMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT8 *)GFL_COLORMAP_Blue_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_UINT8Ptr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Type_set(_swigobj,_swigval) (_swigobj->Type = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_Type_set) {

    GFL_BITMAP_TYPE  _result,_arg1;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_Type_set(self,Type);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Type_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_BITMAP_TYPE )SvIV(ST(1));
    _result = (GFL_BITMAP_TYPE )GFL_BITMAP_Type_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Type_get(_swigobj) ((GFL_BITMAP_TYPE ) _swigobj->Type)
XS(_wrap_GFL_BITMAP_Type_get) {

    GFL_BITMAP_TYPE  _result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_Type_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Type_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_BITMAP_TYPE )GFL_BITMAP_Type_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Origin_set(_swigobj,_swigval) (_swigobj->Origin = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_Origin_set) {

    GFL_ORIGIN  _result,_arg1;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_Origin_set(self,Origin);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Origin_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_ORIGIN )SvIV(ST(1));
    _result = (GFL_ORIGIN )GFL_BITMAP_Origin_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Origin_get(_swigobj) ((GFL_ORIGIN ) _swigobj->Origin)
XS(_wrap_GFL_BITMAP_Origin_get) {

    GFL_ORIGIN  _result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_Origin_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Origin_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_ORIGIN )GFL_BITMAP_Origin_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Width_set(_swigobj,_swigval) (_swigobj->Width = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_Width_set) {

    GFL_INT32  _result,_arg1;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_Width_set(self,Width);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Width_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_BITMAP_Width_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Width_get(_swigobj) ((GFL_INT32 ) _swigobj->Width)
XS(_wrap_GFL_BITMAP_Width_get) {

    GFL_INT32  _result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_Width_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Width_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_BITMAP_Width_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Height_set(_swigobj,_swigval) (_swigobj->Height = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_Height_set) {

    GFL_INT32  _result,_arg1;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_Height_set(self,Height);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Height_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_BITMAP_Height_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Height_get(_swigobj) ((GFL_INT32 ) _swigobj->Height)
XS(_wrap_GFL_BITMAP_Height_get) {

    GFL_INT32  _result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_Height_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Height_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_BITMAP_Height_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_BytesPerLine_set(_swigobj,_swigval) (_swigobj->BytesPerLine = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_BytesPerLine_set) {

    GFL_UINT32  _result,_arg1;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_BytesPerLine_set(self,BytesPerLine);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_BytesPerLine_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_BITMAP_BytesPerLine_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_BytesPerLine_get(_swigobj) ((GFL_UINT32 ) _swigobj->BytesPerLine)
XS(_wrap_GFL_BITMAP_BytesPerLine_get) {

    GFL_UINT32  _result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_BytesPerLine_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_BytesPerLine_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_BITMAP_BytesPerLine_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_BytesPerPixel_set(_swigobj,_swigval) (_swigobj->BytesPerPixel = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_BytesPerPixel_set) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_BytesPerPixel_set(self,BytesPerPixel);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_BytesPerPixel_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT8 )SvIV(ST(1));
    _result = (GFL_UINT8 )GFL_BITMAP_BytesPerPixel_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_BytesPerPixel_get(_swigobj) ((GFL_UINT8 ) _swigobj->BytesPerPixel)
XS(_wrap_GFL_BITMAP_BytesPerPixel_get) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_BytesPerPixel_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_BytesPerPixel_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT8 )GFL_BITMAP_BytesPerPixel_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_BitsPerComponent_set(_swigobj,_swigval) (_swigobj->BitsPerComponent = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_BitsPerComponent_set) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_BitsPerComponent_set(self,BitsPerComponent);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_BitsPerComponent_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT8 )SvIV(ST(1));
    _result = (GFL_UINT8 )GFL_BITMAP_BitsPerComponent_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_BitsPerComponent_get(_swigobj) ((GFL_UINT8 ) _swigobj->BitsPerComponent)
XS(_wrap_GFL_BITMAP_BitsPerComponent_get) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_BitsPerComponent_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_BitsPerComponent_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT8 )GFL_BITMAP_BitsPerComponent_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Xdpi_set(_swigobj,_swigval) (_swigobj->Xdpi = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_Xdpi_set) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_Xdpi_set(self,Xdpi);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Xdpi_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT16 )SvIV(ST(1));
    _result = (GFL_UINT16 )GFL_BITMAP_Xdpi_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Xdpi_get(_swigobj) ((GFL_UINT16 ) _swigobj->Xdpi)
XS(_wrap_GFL_BITMAP_Xdpi_get) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_Xdpi_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Xdpi_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT16 )GFL_BITMAP_Xdpi_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Ydpi_set(_swigobj,_swigval) (_swigobj->Ydpi = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_Ydpi_set) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_Ydpi_set(self,Ydpi);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Ydpi_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT16 )SvIV(ST(1));
    _result = (GFL_UINT16 )GFL_BITMAP_Ydpi_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Ydpi_get(_swigobj) ((GFL_UINT16 ) _swigobj->Ydpi)
XS(_wrap_GFL_BITMAP_Ydpi_get) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_Ydpi_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Ydpi_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT16 )GFL_BITMAP_Ydpi_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_TransparentIndex_set(_swigobj,_swigval) (_swigobj->TransparentIndex = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_TransparentIndex_set) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_INT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_TransparentIndex_set(self,TransparentIndex);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_TransparentIndex_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT16 )SvIV(ST(1));
    _result = (GFL_INT16 )GFL_BITMAP_TransparentIndex_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_TransparentIndex_get(_swigobj) ((GFL_INT16 ) _swigobj->TransparentIndex)
XS(_wrap_GFL_BITMAP_TransparentIndex_get) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_INT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_TransparentIndex_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_TransparentIndex_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_INT16 )GFL_BITMAP_TransparentIndex_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_ColorUsed_set(_swigobj,_swigval) (_swigobj->ColorUsed = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_ColorUsed_set) {

    GFL_INT32  _result,_arg1;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_ColorUsed_set(self,ColorUsed);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_ColorUsed_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_BITMAP_ColorUsed_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_ColorUsed_get(_swigobj) ((GFL_INT32 ) _swigobj->ColorUsed)
XS(_wrap_GFL_BITMAP_ColorUsed_get) {

    GFL_INT32  _result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_ColorUsed_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_ColorUsed_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_BITMAP_ColorUsed_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_ColorMap_set(_swigobj,_swigval) (_swigobj->ColorMap = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_ColorMap_set) {

    GFL_COLORMAP  *_result,*_arg1;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_ColorMap_set(self,ColorMap);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_ColorMap_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_COLORMAP")) {
        croak("Type error in argument 2 of GFL_BITMAP_ColorMap_set. Expected GFL_COLORMAP.");
        XSRETURN(1);
    }
    _result = (GFL_COLORMAP *)GFL_BITMAP_ColorMap_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_COLORMAP", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_ColorMap_get(_swigobj) ((GFL_COLORMAP *) _swigobj->ColorMap)
XS(_wrap_GFL_BITMAP_ColorMap_get) {

    GFL_COLORMAP  *_result;
    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_ColorMap_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_ColorMap_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_COLORMAP *)GFL_BITMAP_ColorMap_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_COLORMAP", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Data_set(_swigobj,_swigval) (_swigobj->Data = _swigval,_swigval)
XS(_wrap_GFL_BITMAP_Data_set) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  *_result,*_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_BITMAP_Data_set(self,Data);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Data_set. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_UINT8Ptr")) {
        croak("Type error in argument 2 of GFL_BITMAP_Data_set. Expected GFL_UINT8Ptr.");
        XSRETURN(1);
    }
    _result = (GFL_UINT8 *)GFL_BITMAP_Data_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_UINT8Ptr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_BITMAP_Data_get(_swigobj) ((GFL_UINT8 *) _swigobj->Data)
XS(_wrap_GFL_BITMAP_Data_get) {

    GFL_BITMAP  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT8  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_BITMAP_Data_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_BITMAP")) {
        croak("Type error in argument 1 of GFL_BITMAP_Data_get. Expected GFL_BITMAP.");
        XSRETURN(1);
    }
    _result = (GFL_UINT8 *)GFL_BITMAP_Data_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_UINT8Ptr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Flags_set(_swigobj,_swigval) (_swigobj->Flags = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Flags_set) {

    GFL_UINT32  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Flags_set(self,Flags);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Flags_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_LOAD_PARAMS_Flags_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Flags_get(_swigobj) ((GFL_UINT32 ) _swigobj->Flags)
XS(_wrap_GFL_LOAD_PARAMS_Flags_get) {

    GFL_UINT32  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Flags_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Flags_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_LOAD_PARAMS_Flags_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_FormatIndex_set(_swigobj,_swigval) (_swigobj->FormatIndex = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_FormatIndex_set) {

    GFL_INT32  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_FormatIndex_set(self,FormatIndex);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_FormatIndex_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_FormatIndex_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_FormatIndex_get(_swigobj) ((GFL_INT32 ) _swigobj->FormatIndex)
XS(_wrap_GFL_LOAD_PARAMS_FormatIndex_get) {

    GFL_INT32  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_FormatIndex_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_FormatIndex_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_FormatIndex_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ImageWanted_set(_swigobj,_swigval) (_swigobj->ImageWanted = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_ImageWanted_set) {

    GFL_INT32  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_ImageWanted_set(self,ImageWanted);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ImageWanted_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_ImageWanted_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ImageWanted_get(_swigobj) ((GFL_INT32 ) _swigobj->ImageWanted)
XS(_wrap_GFL_LOAD_PARAMS_ImageWanted_get) {

    GFL_INT32  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_ImageWanted_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ImageWanted_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_ImageWanted_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Origin_set(_swigobj,_swigval) (_swigobj->Origin = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Origin_set) {

    GFL_ORIGIN  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Origin_set(self,Origin);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Origin_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_ORIGIN )SvIV(ST(1));
    _result = (GFL_ORIGIN )GFL_LOAD_PARAMS_Origin_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Origin_get(_swigobj) ((GFL_ORIGIN ) _swigobj->Origin)
XS(_wrap_GFL_LOAD_PARAMS_Origin_get) {

    GFL_ORIGIN  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Origin_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Origin_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_ORIGIN )GFL_LOAD_PARAMS_Origin_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ColorModel_set(_swigobj,_swigval) (_swigobj->ColorModel = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_ColorModel_set) {

    GFL_BITMAP_TYPE  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_ColorModel_set(self,ColorModel);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ColorModel_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_BITMAP_TYPE )SvIV(ST(1));
    _result = (GFL_BITMAP_TYPE )GFL_LOAD_PARAMS_ColorModel_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ColorModel_get(_swigobj) ((GFL_BITMAP_TYPE ) _swigobj->ColorModel)
XS(_wrap_GFL_LOAD_PARAMS_ColorModel_get) {

    GFL_BITMAP_TYPE  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_ColorModel_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ColorModel_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_BITMAP_TYPE )GFL_LOAD_PARAMS_ColorModel_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_LinePadding_set(_swigobj,_swigval) (_swigobj->LinePadding = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_LinePadding_set) {

    GFL_UINT32  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_LinePadding_set(self,LinePadding);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_LinePadding_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_LOAD_PARAMS_LinePadding_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_LinePadding_get(_swigobj) ((GFL_UINT32 ) _swigobj->LinePadding)
XS(_wrap_GFL_LOAD_PARAMS_LinePadding_get) {

    GFL_UINT32  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_LinePadding_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_LinePadding_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_LOAD_PARAMS_LinePadding_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Width_set(_swigobj,_swigval) (_swigobj->Width = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Width_set) {

    GFL_INT32  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Width_set(self,Width);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Width_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_Width_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Width_get(_swigobj) ((GFL_INT32 ) _swigobj->Width)
XS(_wrap_GFL_LOAD_PARAMS_Width_get) {

    GFL_INT32  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Width_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Width_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_Width_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Height_set(_swigobj,_swigval) (_swigobj->Height = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Height_set) {

    GFL_INT32  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Height_set(self,Height);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Height_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_Height_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Height_get(_swigobj) ((GFL_INT32 ) _swigobj->Height)
XS(_wrap_GFL_LOAD_PARAMS_Height_get) {

    GFL_INT32  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Height_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Height_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_LOAD_PARAMS_Height_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Offset_set(_swigobj,_swigval) (_swigobj->Offset = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Offset_set) {

    GFL_UINT32  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Offset_set(self,Offset);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Offset_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_LOAD_PARAMS_Offset_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Offset_get(_swigobj) ((GFL_UINT32 ) _swigobj->Offset)
XS(_wrap_GFL_LOAD_PARAMS_Offset_get) {

    GFL_UINT32  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Offset_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Offset_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_LOAD_PARAMS_Offset_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ChannelOrder_set(_swigobj,_swigval) (_swigobj->ChannelOrder = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_ChannelOrder_set) {

    GFL_CORDER  _result,_arg1;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_ChannelOrder_set(self,ChannelOrder);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ChannelOrder_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_CORDER )SvIV(ST(1));
    _result = (GFL_CORDER )GFL_LOAD_PARAMS_ChannelOrder_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ChannelOrder_get(_swigobj) ((GFL_CORDER ) _swigobj->ChannelOrder)
XS(_wrap_GFL_LOAD_PARAMS_ChannelOrder_get) {

    GFL_CORDER  _result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_ChannelOrder_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ChannelOrder_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_CORDER )GFL_LOAD_PARAMS_ChannelOrder_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ChannelType_set(_swigobj,_swigval) (_swigobj->ChannelType = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_ChannelType_set) {

    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_CTYPE  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_ChannelType_set(self,ChannelType);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ChannelType_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_CTYPE )SvIV(ST(1));
    _result = (GFL_CTYPE )GFL_LOAD_PARAMS_ChannelType_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_ChannelType_get(_swigobj) ((GFL_CTYPE ) _swigobj->ChannelType)
XS(_wrap_GFL_LOAD_PARAMS_ChannelType_get) {

    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_CTYPE  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_ChannelType_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_ChannelType_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_CTYPE )GFL_LOAD_PARAMS_ChannelType_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_PcdBase_set(_swigobj,_swigval) (_swigobj->PcdBase = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_PcdBase_set) {

    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_PcdBase_set(self,PcdBase);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_PcdBase_set. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT16 )SvIV(ST(1));
    _result = (GFL_UINT16 )GFL_LOAD_PARAMS_PcdBase_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_PcdBase_get(_swigobj) ((GFL_UINT16 ) _swigobj->PcdBase)
XS(_wrap_GFL_LOAD_PARAMS_PcdBase_get) {

    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_UINT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_PcdBase_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_PcdBase_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_UINT16 )GFL_LOAD_PARAMS_PcdBase_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_get(_swigobj) (&_swigobj->Callbacks)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_get) {

    GFL_LOAD_PARAMS_Callbacks  *_result;
    GFL_LOAD_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_get. Expected GFL_LOAD_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_LOAD_PARAMS_Callbacks *)GFL_LOAD_PARAMS_Callbacks_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_LOAD_PARAMS_Callbacks", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Read_set(_swigobj,_swigval) (_swigobj->Read = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Read_set) {

    GFL_READ_CALLBACK  _result,_arg1;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Read_set(self,Read);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Read_set. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_READ_CALLBACK")) {
        croak("Type error in argument 2 of GFL_LOAD_PARAMS_Callbacks_Read_set. Expected GFL_READ_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_READ_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Read_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_READ_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Read_get(_swigobj) ((GFL_READ_CALLBACK ) _swigobj->Read)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Read_get) {

    GFL_READ_CALLBACK  _result;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Read_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Read_get. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_READ_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Read_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_READ_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Tell_set(_swigobj,_swigval) (_swigobj->Tell = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Tell_set) {

    GFL_TELL_CALLBACK  _result,_arg1;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Tell_set(self,Tell);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Tell_set. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_TELL_CALLBACK")) {
        croak("Type error in argument 2 of GFL_LOAD_PARAMS_Callbacks_Tell_set. Expected GFL_TELL_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_TELL_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Tell_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_TELL_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Tell_get(_swigobj) ((GFL_TELL_CALLBACK ) _swigobj->Tell)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Tell_get) {

    GFL_TELL_CALLBACK  _result;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Tell_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Tell_get. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_TELL_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Tell_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_TELL_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Seek_set(_swigobj,_swigval) (_swigobj->Seek = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Seek_set) {

    GFL_SEEK_CALLBACK  _result,_arg1;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Seek_set(self,Seek);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Seek_set. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_SEEK_CALLBACK")) {
        croak("Type error in argument 2 of GFL_LOAD_PARAMS_Callbacks_Seek_set. Expected GFL_SEEK_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_SEEK_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Seek_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_SEEK_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Seek_get(_swigobj) ((GFL_SEEK_CALLBACK ) _swigobj->Seek)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Seek_get) {

    GFL_SEEK_CALLBACK  _result;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Seek_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Seek_get. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_SEEK_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Seek_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_SEEK_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Alloc_set(_swigobj,_swigval) (_swigobj->Alloc = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Alloc_set) {

    GFL_ALLOC_CALLBACK  _result,_arg1;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Alloc_set(self,Alloc);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Alloc_set. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_ALLOC_CALLBACK")) {
        croak("Type error in argument 2 of GFL_LOAD_PARAMS_Callbacks_Alloc_set. Expected GFL_ALLOC_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_ALLOC_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Alloc_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_ALLOC_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Alloc_get(_swigobj) ((GFL_ALLOC_CALLBACK ) _swigobj->Alloc)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Alloc_get) {

    GFL_ALLOC_CALLBACK  _result;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Alloc_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Alloc_get. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_ALLOC_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Alloc_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_ALLOC_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Free_set(_swigobj,_swigval) (_swigobj->Free = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Free_set) {

    GFL_FREE_CALLBACK  _result,_arg1;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Free_set(self,Free);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Free_set. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_FREE_CALLBACK")) {
        croak("Type error in argument 2 of GFL_LOAD_PARAMS_Callbacks_Free_set. Expected GFL_FREE_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_FREE_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Free_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_FREE_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_Free_get(_swigobj) ((GFL_FREE_CALLBACK ) _swigobj->Free)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_Free_get) {

    GFL_FREE_CALLBACK  _result;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_Free_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_Free_get. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_FREE_CALLBACK )GFL_LOAD_PARAMS_Callbacks_Free_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_FREE_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_AllocParam_set(_swigobj,_swigval) (_swigobj->AllocParam = _swigval,_swigval)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_AllocParam_set) {

    void  *_result,*_arg1;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_AllocParam_set(self,AllocParam);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_AllocParam_set. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,(char *) 0 )) {
        croak("Type error in argument 2 of GFL_LOAD_PARAMS_Callbacks_AllocParam_set. Expected voidPtr.");
        XSRETURN(1);
    }
    _result = (void *)GFL_LOAD_PARAMS_Callbacks_AllocParam_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"voidPtr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_LOAD_PARAMS_Callbacks_AllocParam_get(_swigobj) ((void *) _swigobj->AllocParam)
XS(_wrap_GFL_LOAD_PARAMS_Callbacks_AllocParam_get) {

    void  *_result;
    GFL_LOAD_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_LOAD_PARAMS_Callbacks_AllocParam_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_LOAD_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_LOAD_PARAMS_Callbacks_AllocParam_get. Expected GFL_LOAD_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (void *)GFL_LOAD_PARAMS_Callbacks_AllocParam_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"voidPtr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Flags_set(_swigobj,_swigval) (_swigobj->Flags = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Flags_set) {

    GFL_UINT32  _result,_arg1;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Flags_set(self,Flags);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Flags_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_SAVE_PARAMS_Flags_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Flags_get(_swigobj) ((GFL_UINT32 ) _swigobj->Flags)
XS(_wrap_GFL_SAVE_PARAMS_Flags_get) {

    GFL_UINT32  _result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Flags_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Flags_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_SAVE_PARAMS_Flags_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_FormatIndex_set(_swigobj,_swigval) (_swigobj->FormatIndex = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_FormatIndex_set) {

    GFL_INT32  _result,_arg1;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_FormatIndex_set(self,FormatIndex);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_FormatIndex_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_SAVE_PARAMS_FormatIndex_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_FormatIndex_get(_swigobj) ((GFL_INT32 ) _swigobj->FormatIndex)
XS(_wrap_GFL_SAVE_PARAMS_FormatIndex_get) {

    GFL_INT32  _result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_FormatIndex_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_FormatIndex_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_SAVE_PARAMS_FormatIndex_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Compression_set(_swigobj,_swigval) (_swigobj->Compression = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Compression_set) {

    GFL_COMPRESSION  _result,_arg1;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Compression_set(self,Compression);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Compression_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_COMPRESSION )SvIV(ST(1));
    _result = (GFL_COMPRESSION )GFL_SAVE_PARAMS_Compression_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Compression_get(_swigobj) ((GFL_COMPRESSION ) _swigobj->Compression)
XS(_wrap_GFL_SAVE_PARAMS_Compression_get) {

    GFL_COMPRESSION  _result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Compression_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Compression_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_COMPRESSION )GFL_SAVE_PARAMS_Compression_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Quality_set(_swigobj,_swigval) (_swigobj->Quality = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Quality_set) {

    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_INT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Quality_set(self,Quality);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Quality_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT16 )SvIV(ST(1));
    _result = (GFL_INT16 )GFL_SAVE_PARAMS_Quality_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Quality_get(_swigobj) ((GFL_INT16 ) _swigobj->Quality)
XS(_wrap_GFL_SAVE_PARAMS_Quality_get) {

    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_INT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Quality_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Quality_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_INT16 )GFL_SAVE_PARAMS_Quality_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_CompressionLevel_set(_swigobj,_swigval) (_swigobj->CompressionLevel = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_CompressionLevel_set) {

    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_INT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_CompressionLevel_set(self,CompressionLevel);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_CompressionLevel_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT16 )SvIV(ST(1));
    _result = (GFL_INT16 )GFL_SAVE_PARAMS_CompressionLevel_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_CompressionLevel_get(_swigobj) ((GFL_INT16 ) _swigobj->CompressionLevel)
XS(_wrap_GFL_SAVE_PARAMS_CompressionLevel_get) {

    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_INT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_CompressionLevel_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_CompressionLevel_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_INT16 )GFL_SAVE_PARAMS_CompressionLevel_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Interlaced_set(_swigobj,_swigval) (_swigobj->Interlaced = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Interlaced_set) {

    GFL_BOOL  _result,_arg1;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Interlaced_set(self,Interlaced);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Interlaced_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_BOOL )SvIV(ST(1));
    _result = (GFL_BOOL )GFL_SAVE_PARAMS_Interlaced_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Interlaced_get(_swigobj) ((GFL_BOOL ) _swigobj->Interlaced)
XS(_wrap_GFL_SAVE_PARAMS_Interlaced_get) {

    GFL_BOOL  _result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Interlaced_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Interlaced_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_BOOL )GFL_SAVE_PARAMS_Interlaced_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Progressive_set(_swigobj,_swigval) (_swigobj->Progressive = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Progressive_set) {

    GFL_BOOL  _result,_arg1;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Progressive_set(self,Progressive);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Progressive_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_BOOL )SvIV(ST(1));
    _result = (GFL_BOOL )GFL_SAVE_PARAMS_Progressive_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Progressive_get(_swigobj) ((GFL_BOOL ) _swigobj->Progressive)
XS(_wrap_GFL_SAVE_PARAMS_Progressive_get) {

    GFL_BOOL  _result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Progressive_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Progressive_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_BOOL )GFL_SAVE_PARAMS_Progressive_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Offset_set(_swigobj,_swigval) (_swigobj->Offset = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Offset_set) {

    GFL_UINT32  _result,_arg1;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Offset_set(self,Offset);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Offset_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_SAVE_PARAMS_Offset_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Offset_get(_swigobj) ((GFL_UINT32 ) _swigobj->Offset)
XS(_wrap_GFL_SAVE_PARAMS_Offset_get) {

    GFL_UINT32  _result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Offset_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Offset_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_SAVE_PARAMS_Offset_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_ChannelOrder_set(_swigobj,_swigval) (_swigobj->ChannelOrder = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_ChannelOrder_set) {

    GFL_CORDER  _result,_arg1;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_ChannelOrder_set(self,ChannelOrder);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_ChannelOrder_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_CORDER )SvIV(ST(1));
    _result = (GFL_CORDER )GFL_SAVE_PARAMS_ChannelOrder_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_ChannelOrder_get(_swigobj) ((GFL_CORDER ) _swigobj->ChannelOrder)
XS(_wrap_GFL_SAVE_PARAMS_ChannelOrder_get) {

    GFL_CORDER  _result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_ChannelOrder_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_ChannelOrder_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_CORDER )GFL_SAVE_PARAMS_ChannelOrder_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_ChannelType_set(_swigobj,_swigval) (_swigobj->ChannelType = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_ChannelType_set) {

    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_CTYPE  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_ChannelType_set(self,ChannelType);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_ChannelType_set. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _arg1 = (GFL_CTYPE )SvIV(ST(1));
    _result = (GFL_CTYPE )GFL_SAVE_PARAMS_ChannelType_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_ChannelType_get(_swigobj) ((GFL_CTYPE ) _swigobj->ChannelType)
XS(_wrap_GFL_SAVE_PARAMS_ChannelType_get) {

    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    GFL_CTYPE  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_ChannelType_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_ChannelType_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_CTYPE )GFL_SAVE_PARAMS_ChannelType_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_get(_swigobj) (&_swigobj->Callbacks)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_get) {

    GFL_SAVE_PARAMS_Callbacks  *_result;
    GFL_SAVE_PARAMS  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_get. Expected GFL_SAVE_PARAMS.");
        XSRETURN(1);
    }
    _result = (GFL_SAVE_PARAMS_Callbacks *)GFL_SAVE_PARAMS_Callbacks_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_SAVE_PARAMS_Callbacks", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Write_set(_swigobj,_swigval) (_swigobj->Write = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Write_set) {

    GFL_WRITE_CALLBACK  _result,_arg1;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Write_set(self,Write);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Write_set. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_WRITE_CALLBACK")) {
        croak("Type error in argument 2 of GFL_SAVE_PARAMS_Callbacks_Write_set. Expected GFL_WRITE_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_WRITE_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Write_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_WRITE_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Write_get(_swigobj) ((GFL_WRITE_CALLBACK ) _swigobj->Write)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Write_get) {

    GFL_WRITE_CALLBACK  _result;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Write_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Write_get. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_WRITE_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Write_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_WRITE_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Tell_set(_swigobj,_swigval) (_swigobj->Tell = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Tell_set) {

    GFL_TELL_CALLBACK  _result,_arg1;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Tell_set(self,Tell);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Tell_set. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_TELL_CALLBACK")) {
        croak("Type error in argument 2 of GFL_SAVE_PARAMS_Callbacks_Tell_set. Expected GFL_TELL_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_TELL_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Tell_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_TELL_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Tell_get(_swigobj) ((GFL_TELL_CALLBACK ) _swigobj->Tell)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Tell_get) {

    GFL_TELL_CALLBACK  _result;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Tell_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Tell_get. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_TELL_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Tell_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_TELL_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Seek_set(_swigobj,_swigval) (_swigobj->Seek = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Seek_set) {

    GFL_SEEK_CALLBACK  _result,_arg1;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Seek_set(self,Seek);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Seek_set. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_SEEK_CALLBACK")) {
        croak("Type error in argument 2 of GFL_SAVE_PARAMS_Callbacks_Seek_set. Expected GFL_SEEK_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_SEEK_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Seek_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_SEEK_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Seek_get(_swigobj) ((GFL_SEEK_CALLBACK ) _swigobj->Seek)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Seek_get) {

    GFL_SEEK_CALLBACK  _result;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Seek_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Seek_get. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_SEEK_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Seek_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_SEEK_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Alloc_set(_swigobj,_swigval) (_swigobj->Alloc = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Alloc_set) {

    GFL_ALLOC_CALLBACK  _result,_arg1;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Alloc_set(self,Alloc);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Alloc_set. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_ALLOC_CALLBACK")) {
        croak("Type error in argument 2 of GFL_SAVE_PARAMS_Callbacks_Alloc_set. Expected GFL_ALLOC_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_ALLOC_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Alloc_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_ALLOC_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Alloc_get(_swigobj) ((GFL_ALLOC_CALLBACK ) _swigobj->Alloc)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Alloc_get) {

    GFL_ALLOC_CALLBACK  _result;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Alloc_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Alloc_get. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_ALLOC_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Alloc_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_ALLOC_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Free_set(_swigobj,_swigval) (_swigobj->Free = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Free_set) {

    GFL_FREE_CALLBACK  _result,_arg1;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Free_set(self,Free);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Free_set. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,"GFL_FREE_CALLBACK")) {
        croak("Type error in argument 2 of GFL_SAVE_PARAMS_Callbacks_Free_set. Expected GFL_FREE_CALLBACK.");
        XSRETURN(1);
    }
    _result = (GFL_FREE_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Free_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_FREE_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_Free_get(_swigobj) ((GFL_FREE_CALLBACK ) _swigobj->Free)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_Free_get) {

    GFL_FREE_CALLBACK  _result;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_Free_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_Free_get. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (GFL_FREE_CALLBACK )GFL_SAVE_PARAMS_Callbacks_Free_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"GFL_FREE_CALLBACK", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_AllocParam_set(_swigobj,_swigval) (_swigobj->AllocParam = _swigval,_swigval)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_AllocParam_set) {

    void  *_result,*_arg1;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_AllocParam_set(self,AllocParam);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_AllocParam_set. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    if (SWIG_GetPtr(ST(1),(void **) &_arg1,(char *) 0 )) {
        croak("Type error in argument 2 of GFL_SAVE_PARAMS_Callbacks_AllocParam_set. Expected voidPtr.");
        XSRETURN(1);
    }
    _result = (void *)GFL_SAVE_PARAMS_Callbacks_AllocParam_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"voidPtr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_SAVE_PARAMS_Callbacks_AllocParam_get(_swigobj) ((void *) _swigobj->AllocParam)
XS(_wrap_GFL_SAVE_PARAMS_Callbacks_AllocParam_get) {

    void  *_result;
    GFL_SAVE_PARAMS_Callbacks  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_SAVE_PARAMS_Callbacks_AllocParam_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_SAVE_PARAMS_Callbacks")) {
        croak("Type error in argument 1 of GFL_SAVE_PARAMS_Callbacks_AllocParam_get. Expected GFL_SAVE_PARAMS_Callbacks.");
        XSRETURN(1);
    }
    _result = (void *)GFL_SAVE_PARAMS_Callbacks_AllocParam_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setref_pv(ST(argvi++),"voidPtr", (void *) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Type_set(_swigobj,_swigval) (_swigobj->Type = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_Type_set) {

    GFL_BITMAP_TYPE  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_Type_set(self,Type);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Type_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_BITMAP_TYPE )SvIV(ST(1));
    _result = (GFL_BITMAP_TYPE )GFL_FILE_INFORMATION_Type_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Type_get(_swigobj) ((GFL_BITMAP_TYPE ) _swigobj->Type)
XS(_wrap_GFL_FILE_INFORMATION_Type_get) {

    GFL_BITMAP_TYPE  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Type_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Type_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_BITMAP_TYPE )GFL_FILE_INFORMATION_Type_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Width_set(_swigobj,_swigval) (_swigobj->Width = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_Width_set) {

    GFL_INT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_Width_set(self,Width);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Width_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_Width_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Width_get(_swigobj) ((GFL_INT32 ) _swigobj->Width)
XS(_wrap_GFL_FILE_INFORMATION_Width_get) {

    GFL_INT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Width_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Width_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_Width_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Height_set(_swigobj,_swigval) (_swigobj->Height = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_Height_set) {

    GFL_INT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_Height_set(self,Height);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Height_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_Height_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Height_get(_swigobj) ((GFL_INT32 ) _swigobj->Height)
XS(_wrap_GFL_FILE_INFORMATION_Height_get) {

    GFL_INT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Height_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Height_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_Height_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_FormatIndex_set(_swigobj,_swigval) (_swigobj->FormatIndex = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_FormatIndex_set) {

    GFL_INT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_FormatIndex_set(self,FormatIndex);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_FormatIndex_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_FormatIndex_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_FormatIndex_get(_swigobj) ((GFL_INT32 ) _swigobj->FormatIndex)
XS(_wrap_GFL_FILE_INFORMATION_FormatIndex_get) {

    GFL_INT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_FormatIndex_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_FormatIndex_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_FormatIndex_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_FormatName_get(_swigobj) ((char *) _swigobj->FormatName)
XS(_wrap_GFL_FILE_INFORMATION_FormatName_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_FormatName_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_FormatName_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (char *)GFL_FILE_INFORMATION_FormatName_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Description_get(_swigobj) ((char *) _swigobj->Description)
XS(_wrap_GFL_FILE_INFORMATION_Description_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Description_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Description_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (char *)GFL_FILE_INFORMATION_Description_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Xdpi_set(_swigobj,_swigval) (_swigobj->Xdpi = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_Xdpi_set) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_Xdpi_set(self,Xdpi);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Xdpi_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT16 )SvIV(ST(1));
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_Xdpi_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Xdpi_get(_swigobj) ((GFL_UINT16 ) _swigobj->Xdpi)
XS(_wrap_GFL_FILE_INFORMATION_Xdpi_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Xdpi_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Xdpi_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_Xdpi_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Ydpi_set(_swigobj,_swigval) (_swigobj->Ydpi = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_Ydpi_set) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_Ydpi_set(self,Ydpi);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Ydpi_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT16 )SvIV(ST(1));
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_Ydpi_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Ydpi_get(_swigobj) ((GFL_UINT16 ) _swigobj->Ydpi)
XS(_wrap_GFL_FILE_INFORMATION_Ydpi_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Ydpi_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Ydpi_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_Ydpi_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_BitsPerPlane_set(_swigobj,_swigval) (_swigobj->BitsPerPlane = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_BitsPerPlane_set) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_BitsPerPlane_set(self,BitsPerPlane);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_BitsPerPlane_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT16 )SvIV(ST(1));
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_BitsPerPlane_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_BitsPerPlane_get(_swigobj) ((GFL_UINT16 ) _swigobj->BitsPerPlane)
XS(_wrap_GFL_FILE_INFORMATION_BitsPerPlane_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_BitsPerPlane_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_BitsPerPlane_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_BitsPerPlane_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_NumberOfPlanes_set(_swigobj,_swigval) (_swigobj->NumberOfPlanes = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_NumberOfPlanes_set) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result,_arg1;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_NumberOfPlanes_set(self,NumberOfPlanes);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_NumberOfPlanes_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT16 )SvIV(ST(1));
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_NumberOfPlanes_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_NumberOfPlanes_get(_swigobj) ((GFL_UINT16 ) _swigobj->NumberOfPlanes)
XS(_wrap_GFL_FILE_INFORMATION_NumberOfPlanes_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    GFL_UINT16  _result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_NumberOfPlanes_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_NumberOfPlanes_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT16 )GFL_FILE_INFORMATION_NumberOfPlanes_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_BytesPerPlane_set(_swigobj,_swigval) (_swigobj->BytesPerPlane = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_BytesPerPlane_set) {

    GFL_UINT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_BytesPerPlane_set(self,BytesPerPlane);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_BytesPerPlane_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_FILE_INFORMATION_BytesPerPlane_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_BytesPerPlane_get(_swigobj) ((GFL_UINT32 ) _swigobj->BytesPerPlane)
XS(_wrap_GFL_FILE_INFORMATION_BytesPerPlane_get) {

    GFL_UINT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_BytesPerPlane_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_BytesPerPlane_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_FILE_INFORMATION_BytesPerPlane_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_NumberOfImages_set(_swigobj,_swigval) (_swigobj->NumberOfImages = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_NumberOfImages_set) {

    GFL_INT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_NumberOfImages_set(self,NumberOfImages);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_NumberOfImages_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_NumberOfImages_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_NumberOfImages_get(_swigobj) ((GFL_INT32 ) _swigobj->NumberOfImages)
XS(_wrap_GFL_FILE_INFORMATION_NumberOfImages_get) {

    GFL_INT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_NumberOfImages_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_NumberOfImages_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_FILE_INFORMATION_NumberOfImages_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_FileSize_set(_swigobj,_swigval) (_swigobj->FileSize = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_FileSize_set) {

    GFL_UINT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_FileSize_set(self,FileSize);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_FileSize_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_FILE_INFORMATION_FileSize_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_FileSize_get(_swigobj) ((GFL_UINT32 ) _swigobj->FileSize)
XS(_wrap_GFL_FILE_INFORMATION_FileSize_get) {

    GFL_UINT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_FileSize_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_FileSize_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_FILE_INFORMATION_FileSize_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Origin_set(_swigobj,_swigval) (_swigobj->Origin = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_Origin_set) {

    GFL_ORIGIN  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_Origin_set(self,Origin);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Origin_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_ORIGIN )SvIV(ST(1));
    _result = (GFL_ORIGIN )GFL_FILE_INFORMATION_Origin_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Origin_get(_swigobj) ((GFL_ORIGIN ) _swigobj->Origin)
XS(_wrap_GFL_FILE_INFORMATION_Origin_get) {

    GFL_ORIGIN  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Origin_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Origin_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_ORIGIN )GFL_FILE_INFORMATION_Origin_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Compression_set(_swigobj,_swigval) (_swigobj->Compression = _swigval,_swigval)
XS(_wrap_GFL_FILE_INFORMATION_Compression_set) {

    GFL_COMPRESSION  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FILE_INFORMATION_Compression_set(self,Compression);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Compression_set. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_COMPRESSION )SvIV(ST(1));
    _result = (GFL_COMPRESSION )GFL_FILE_INFORMATION_Compression_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_Compression_get(_swigobj) ((GFL_COMPRESSION ) _swigobj->Compression)
XS(_wrap_GFL_FILE_INFORMATION_Compression_get) {

    GFL_COMPRESSION  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_Compression_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_Compression_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_COMPRESSION )GFL_FILE_INFORMATION_Compression_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FILE_INFORMATION_CompressionDescription_get(_swigobj) ((char *) _swigobj->CompressionDescription)
XS(_wrap_GFL_FILE_INFORMATION_CompressionDescription_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FILE_INFORMATION  *_arg0;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FILE_INFORMATION_CompressionDescription_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FILE_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FILE_INFORMATION_CompressionDescription_get. Expected GFL_FILE_INFORMATION.");
        XSRETURN(1);
    }
    _result = (char *)GFL_FILE_INFORMATION_CompressionDescription_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_Index_set(_swigobj,_swigval) (_swigobj->Index = _swigval,_swigval)
XS(_wrap_GFL_FORMAT_INFORMATION_Index_set) {

    GFL_INT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FORMAT_INFORMATION_Index_set(self,Index);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_Index_set. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_FORMAT_INFORMATION_Index_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_Index_get(_swigobj) ((GFL_INT32 ) _swigobj->Index)
XS(_wrap_GFL_FORMAT_INFORMATION_Index_get) {

    GFL_INT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FORMAT_INFORMATION_Index_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_Index_get. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_FORMAT_INFORMATION_Index_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_Name_get(_swigobj) ((char *) _swigobj->Name)
XS(_wrap_GFL_FORMAT_INFORMATION_Name_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FORMAT_INFORMATION_Name_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_Name_get. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (char *)GFL_FORMAT_INFORMATION_Name_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_Description_get(_swigobj) ((char *) _swigobj->Description)
XS(_wrap_GFL_FORMAT_INFORMATION_Description_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FORMAT_INFORMATION_Description_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_Description_get. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (char *)GFL_FORMAT_INFORMATION_Description_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_Status_set(_swigobj,_swigval) (_swigobj->Status = _swigval,_swigval)
XS(_wrap_GFL_FORMAT_INFORMATION_Status_set) {

    GFL_UINT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FORMAT_INFORMATION_Status_set(self,Status);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_Status_set. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_FORMAT_INFORMATION_Status_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_Status_get(_swigobj) ((GFL_UINT32 ) _swigobj->Status)
XS(_wrap_GFL_FORMAT_INFORMATION_Status_get) {

    GFL_UINT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FORMAT_INFORMATION_Status_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_Status_get. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_FORMAT_INFORMATION_Status_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_NumberOfExtension_set(_swigobj,_swigval) (_swigobj->NumberOfExtension = _swigval,_swigval)
XS(_wrap_GFL_FORMAT_INFORMATION_NumberOfExtension_set) {

    GFL_UINT32  _result,_arg1;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_FORMAT_INFORMATION_NumberOfExtension_set(self,NumberOfExtension);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_NumberOfExtension_set. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _arg1 = (GFL_UINT32 )SvIV(ST(1));
    _result = (GFL_UINT32 )GFL_FORMAT_INFORMATION_NumberOfExtension_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_NumberOfExtension_get(_swigobj) ((GFL_UINT32 ) _swigobj->NumberOfExtension)
XS(_wrap_GFL_FORMAT_INFORMATION_NumberOfExtension_get) {

    GFL_UINT32  _result;
    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FORMAT_INFORMATION_NumberOfExtension_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_NumberOfExtension_get. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (GFL_UINT32 )GFL_FORMAT_INFORMATION_NumberOfExtension_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_FORMAT_INFORMATION_Extension_get(_swigobj) ((char *) _swigobj->Extension)
XS(_wrap_GFL_FORMAT_INFORMATION_Extension_get) {

    int argvi = 0;
    dXSARGS ;
    GFL_FORMAT_INFORMATION  *_arg0;
    char  *_result;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_FORMAT_INFORMATION_Extension_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_FORMAT_INFORMATION")) {
        croak("Type error in argument 1 of GFL_FORMAT_INFORMATION_Extension_get. Expected GFL_FORMAT_INFORMATION.");
        XSRETURN(1);
    }
    _result = (char *)GFL_FORMAT_INFORMATION_Extension_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setpv((SV*)ST(argvi++),(char *) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_x_set(_swigobj,_swigval) (_swigobj->x = _swigval,_swigval)
XS(_wrap_GFL_RECT_x_set) {

    GFL_INT32  _result,_arg1;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_RECT_x_set(self,x);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_x_set. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_RECT_x_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_x_get(_swigobj) ((GFL_INT32 ) _swigobj->x)
XS(_wrap_GFL_RECT_x_get) {

    GFL_INT32  _result;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_RECT_x_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_x_get. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_RECT_x_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_y_set(_swigobj,_swigval) (_swigobj->y = _swigval,_swigval)
XS(_wrap_GFL_RECT_y_set) {

    GFL_INT32  _result,_arg1;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_RECT_y_set(self,y);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_y_set. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_RECT_y_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_y_get(_swigobj) ((GFL_INT32 ) _swigobj->y)
XS(_wrap_GFL_RECT_y_get) {

    GFL_INT32  _result;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_RECT_y_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_y_get. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_RECT_y_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_w_set(_swigobj,_swigval) (_swigobj->w = _swigval,_swigval)
XS(_wrap_GFL_RECT_w_set) {

    GFL_INT32  _result,_arg1;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_RECT_w_set(self,w);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_w_set. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_RECT_w_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_w_get(_swigobj) ((GFL_INT32 ) _swigobj->w)
XS(_wrap_GFL_RECT_w_get) {

    GFL_INT32  _result;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_RECT_w_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_w_get. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_RECT_w_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_h_set(_swigobj,_swigval) (_swigobj->h = _swigval,_swigval)
XS(_wrap_GFL_RECT_h_set) {

    GFL_INT32  _result,_arg1;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 2) || (items > 2)) 
        croak("Usage: GFL_RECT_h_set(self,h);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_h_set. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _arg1 = (GFL_INT32 )SvIV(ST(1));
    _result = (GFL_INT32 )GFL_RECT_h_set(_arg0,_arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

#define GFL_RECT_h_get(_swigobj) ((GFL_INT32 ) _swigobj->h)
XS(_wrap_GFL_RECT_h_get) {

    GFL_INT32  _result;
    GFL_RECT  *_arg0;
    int argvi = 0;
    dXSARGS ;
    cv = cv;
    if ((items < 1) || (items > 1)) 
        croak("Usage: GFL_RECT_h_get(self);");
    if (SWIG_GetPtr(ST(0),(void **) &_arg0,"GFL_RECT")) {
        croak("Type error in argument 1 of GFL_RECT_h_get. Expected GFL_RECT.");
        XSRETURN(1);
    }
    _result = (GFL_INT32 )GFL_RECT_h_get(_arg0);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) _result);
    XSRETURN(argvi);
}

/*
 * This table is used by the pointer type-checker
 */
static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
    { "unsigned int","int",0},
    { "signed int","int",0},
    { "unsigned long","GFL_UINT32",0},
    { "unsigned long","long",0},
    { "signed long","GFL_INT32",0},
    { "signed long","long",0},
    { "GFL_UINT8","GFL_BOOL",0},
    { "GFL_UINT8","unsigned char",0},
    { "GFL_ORIGIN","GFL_MODE_PARAMS",0},
    { "GFL_ORIGIN","GFL_MODE",0},
    { "GFL_ORIGIN","GFL_CTYPE",0},
    { "GFL_ORIGIN","GFL_CORDER",0},
    { "GFL_ORIGIN","GFL_BITMAP_TYPE",0},
    { "GFL_ORIGIN","GFL_COMPRESSION",0},
    { "GFL_ORIGIN","GFL_UINT16",0},
    { "GFL_ORIGIN","short",0},
    { "GFL_ORIGIN","unsigned short",0},
    { "GFL_COMPRESSION","GFL_MODE_PARAMS",0},
    { "GFL_COMPRESSION","GFL_MODE",0},
    { "GFL_COMPRESSION","GFL_CTYPE",0},
    { "GFL_COMPRESSION","GFL_CORDER",0},
    { "GFL_COMPRESSION","GFL_BITMAP_TYPE",0},
    { "GFL_COMPRESSION","GFL_UINT16",0},
    { "GFL_COMPRESSION","short",0},
    { "GFL_COMPRESSION","unsigned short",0},
    { "GFL_COMPRESSION","GFL_ORIGIN",0},
    { "GFL_BITMAP_TYPE","GFL_MODE_PARAMS",0},
    { "GFL_BITMAP_TYPE","GFL_MODE",0},
    { "GFL_BITMAP_TYPE","GFL_CTYPE",0},
    { "GFL_BITMAP_TYPE","GFL_CORDER",0},
    { "GFL_BITMAP_TYPE","GFL_UINT16",0},
    { "GFL_BITMAP_TYPE","short",0},
    { "GFL_BITMAP_TYPE","unsigned short",0},
    { "GFL_BITMAP_TYPE","GFL_ORIGIN",0},
    { "GFL_BITMAP_TYPE","GFL_COMPRESSION",0},
    { "GFL_INT8","signed char",0},
    { "GFL_MODE","GFL_MODE_PARAMS",0},
    { "GFL_MODE","GFL_UINT16",0},
    { "GFL_MODE","short",0},
    { "GFL_MODE","unsigned short",0},
    { "GFL_MODE","GFL_ORIGIN",0},
    { "GFL_MODE","GFL_COMPRESSION",0},
    { "GFL_MODE","GFL_BITMAP_TYPE",0},
    { "GFL_MODE","GFL_CORDER",0},
    { "GFL_MODE","GFL_CTYPE",0},
    { "GFL_INT32","signed long",0},
    { "GFL_INT32","long",0},
    { "GFL_MODE_PARAMS","GFL_UINT16",0},
    { "GFL_MODE_PARAMS","short",0},
    { "GFL_MODE_PARAMS","unsigned short",0},
    { "GFL_MODE_PARAMS","GFL_ORIGIN",0},
    { "GFL_MODE_PARAMS","GFL_COMPRESSION",0},
    { "GFL_MODE_PARAMS","GFL_BITMAP_TYPE",0},
    { "GFL_MODE_PARAMS","GFL_CORDER",0},
    { "GFL_MODE_PARAMS","GFL_CTYPE",0},
    { "GFL_MODE_PARAMS","GFL_MODE",0},
    { "long","GFL_UINT32",0},
    { "long","GFL_INT32",0},
    { "long","unsigned long",0},
    { "long","signed long",0},
    { "GFL_UINT16","GFL_MODE_PARAMS",0},
    { "GFL_UINT16","GFL_MODE",0},
    { "GFL_UINT16","GFL_CTYPE",0},
    { "GFL_UINT16","GFL_CORDER",0},
    { "GFL_UINT16","GFL_BITMAP_TYPE",0},
    { "GFL_UINT16","GFL_COMPRESSION",0},
    { "GFL_UINT16","GFL_ORIGIN",0},
    { "GFL_UINT16","unsigned short",0},
    { "GFL_UINT16","short",0},
    { "GFL_BOOL","unsigned char",0},
    { "GFL_BOOL","GFL_UINT8",0},
    { "int","unsigned int",0},
    { "int","signed int",0},
    { "unsigned short","GFL_MODE_PARAMS",0},
    { "unsigned short","GFL_MODE",0},
    { "unsigned short","GFL_CTYPE",0},
    { "unsigned short","GFL_CORDER",0},
    { "unsigned short","GFL_BITMAP_TYPE",0},
    { "unsigned short","GFL_COMPRESSION",0},
    { "unsigned short","GFL_ORIGIN",0},
    { "unsigned short","GFL_UINT16",0},
    { "unsigned short","short",0},
    { "signed short","GFL_ERROR",0},
    { "signed short","GFL_INT16",0},
    { "signed short","short",0},
    { "GFL_CORDER","GFL_MODE_PARAMS",0},
    { "GFL_CORDER","GFL_MODE",0},
    { "GFL_CORDER","GFL_CTYPE",0},
    { "GFL_CORDER","GFL_UINT16",0},
    { "GFL_CORDER","short",0},
    { "GFL_CORDER","unsigned short",0},
    { "GFL_CORDER","GFL_ORIGIN",0},
    { "GFL_CORDER","GFL_COMPRESSION",0},
    { "GFL_CORDER","GFL_BITMAP_TYPE",0},
    { "unsigned char","GFL_BOOL",0},
    { "unsigned char","GFL_UINT8",0},
    { "signed char","GFL_INT8",0},
    { "GFL_CTYPE","GFL_MODE_PARAMS",0},
    { "GFL_CTYPE","GFL_MODE",0},
    { "GFL_CTYPE","GFL_UINT16",0},
    { "GFL_CTYPE","short",0},
    { "GFL_CTYPE","unsigned short",0},
    { "GFL_CTYPE","GFL_ORIGIN",0},
    { "GFL_CTYPE","GFL_COMPRESSION",0},
    { "GFL_CTYPE","GFL_BITMAP_TYPE",0},
    { "GFL_CTYPE","GFL_CORDER",0},
    { "GFL_INT16","GFL_ERROR",0},
    { "GFL_INT16","signed short",0},
    { "GFL_INT16","short",0},
    { "short","GFL_MODE_PARAMS",0},
    { "short","GFL_MODE",0},
    { "short","GFL_CTYPE",0},
    { "short","GFL_CORDER",0},
    { "short","GFL_BITMAP_TYPE",0},
    { "short","GFL_COMPRESSION",0},
    { "short","GFL_ORIGIN",0},
    { "short","GFL_ERROR",0},
    { "short","GFL_UINT16",0},
    { "short","GFL_INT16",0},
    { "short","unsigned short",0},
    { "short","signed short",0},
    { "GFL_ERROR","GFL_INT16",0},
    { "GFL_ERROR","short",0},
    { "GFL_ERROR","signed short",0},
    { "GFL_UINT32","unsigned long",0},
    { "GFL_UINT32","long",0},
{0,0,0}};

/*
typedef struct {
    const char *name; 
    void *(*convert)(void *);
} SwigType;
static SwigType unsigned int[] = {{ "int", 0},{0,0}};
static SwigType signed int[] = {{ "int", 0},{0,0}};
static SwigType unsigned long[] = {{ "GFL_UINT32", 0},{ "long", 0},{0,0}};
static SwigType signed long[] = {{ "GFL_INT32", 0},{ "long", 0},{0,0}};
static SwigType GFL_UINT8[] = {{ "GFL_BOOL", 0},{ "unsigned char", 0},{0,0}};
static SwigType GFL_ORIGIN[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_CTYPE", 0},{ "GFL_CORDER", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_COMPRESSION", 0},{ "GFL_UINT16", 0},{ "short", 0},{ "unsigned short", 0},{0,0}};
static SwigType GFL_COMPRESSION[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_CTYPE", 0},{ "GFL_CORDER", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_UINT16", 0},{ "short", 0},{ "unsigned short", 0},{ "GFL_ORIGIN", 0},{0,0}};
static SwigType GFL_BITMAP_TYPE[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_CTYPE", 0},{ "GFL_CORDER", 0},{ "GFL_UINT16", 0},{ "short", 0},{ "unsigned short", 0},{ "GFL_ORIGIN", 0},{ "GFL_COMPRESSION", 0},{0,0}};
static SwigType GFL_INT8[] = {{ "signed char", 0},{0,0}};
static SwigType GFL_MODE[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_UINT16", 0},{ "short", 0},{ "unsigned short", 0},{ "GFL_ORIGIN", 0},{ "GFL_COMPRESSION", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_CORDER", 0},{ "GFL_CTYPE", 0},{0,0}};
static SwigType GFL_INT32[] = {{ "signed long", 0},{ "long", 0},{0,0}};
static SwigType GFL_MODE_PARAMS[] = {{ "GFL_UINT16", 0},{ "short", 0},{ "unsigned short", 0},{ "GFL_ORIGIN", 0},{ "GFL_COMPRESSION", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_CORDER", 0},{ "GFL_CTYPE", 0},{ "GFL_MODE", 0},{0,0}};
static SwigType long[] = {{ "GFL_UINT32", 0},{ "GFL_INT32", 0},{ "unsigned long", 0},{ "signed long", 0},{0,0}};
static SwigType GFL_UINT16[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_CTYPE", 0},{ "GFL_CORDER", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_COMPRESSION", 0},{ "GFL_ORIGIN", 0},{ "unsigned short", 0},{ "short", 0},{0,0}};
static SwigType GFL_BOOL[] = {{ "unsigned char", 0},{ "GFL_UINT8", 0},{0,0}};
static SwigType int[] = {{ "unsigned int", 0},{ "signed int", 0},{0,0}};
static SwigType unsigned short[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_CTYPE", 0},{ "GFL_CORDER", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_COMPRESSION", 0},{ "GFL_ORIGIN", 0},{ "GFL_UINT16", 0},{ "short", 0},{0,0}};
static SwigType signed short[] = {{ "GFL_ERROR", 0},{ "GFL_INT16", 0},{ "short", 0},{0,0}};
static SwigType GFL_CORDER[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_CTYPE", 0},{ "GFL_UINT16", 0},{ "short", 0},{ "unsigned short", 0},{ "GFL_ORIGIN", 0},{ "GFL_COMPRESSION", 0},{ "GFL_BITMAP_TYPE", 0},{0,0}};
static SwigType unsigned char[] = {{ "GFL_BOOL", 0},{ "GFL_UINT8", 0},{0,0}};
static SwigType signed char[] = {{ "GFL_INT8", 0},{0,0}};
static SwigType GFL_CTYPE[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_UINT16", 0},{ "short", 0},{ "unsigned short", 0},{ "GFL_ORIGIN", 0},{ "GFL_COMPRESSION", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_CORDER", 0},{0,0}};
static SwigType GFL_INT16[] = {{ "GFL_ERROR", 0},{ "signed short", 0},{ "short", 0},{0,0}};
static SwigType short[] = {{ "GFL_MODE_PARAMS", 0},{ "GFL_MODE", 0},{ "GFL_CTYPE", 0},{ "GFL_CORDER", 0},{ "GFL_BITMAP_TYPE", 0},{ "GFL_COMPRESSION", 0},{ "GFL_ORIGIN", 0},{ "GFL_ERROR", 0},{ "GFL_UINT16", 0},{ "GFL_INT16", 0},{ "unsigned short", 0},{ "signed short", 0},{0,0}};
static SwigType GFL_ERROR[] = {{ "GFL_INT16", 0},{ "short", 0},{ "signed short", 0},{0,0}};
static SwigType GFL_UINT32[] = {{ "unsigned long", 0},{ "long", 0},{0,0}};
*/

XS(_wrap_perl5_GFL_var_init) {
    dXSARGS;
    SV *sv;
    cv = cv; items = items;
    swig_setpv("GFLc::GFL_VERSION", "1.30");
    swig_setiv("GFLc::GFL_FALSE", (long) 0);
    swig_setiv("GFLc::GFL_TRUE", (long) 1);
    swig_setiv("GFLc::GFL_NO_ERROR", (long) 0);
    swig_setiv("GFLc::GFL_ERROR_FILE_OPEN", (long) 1);
    swig_setiv("GFLc::GFL_ERROR_FILE_READ", (long) 2);
    swig_setiv("GFLc::GFL_ERROR_FILE_CREATE", (long) 3);
    swig_setiv("GFLc::GFL_ERROR_FILE_WRITE", (long) 4);
    swig_setiv("GFLc::GFL_ERROR_NO_MEMORY", (long) 5);
    swig_setiv("GFLc::GFL_ERROR_UNKNOWN_FORMAT", (long) 6);
    swig_setiv("GFLc::GFL_ERROR_BAD_BITMAP", (long) 7);
    swig_setiv("GFLc::GFL_ERROR_BAD_FORMAT_INDEX", (long) 10);
    swig_setiv("GFLc::GFL_UNKNOWN_ERROR", (long) 255);
    swig_setiv("GFLc::GFL_LEFT", (long) 0x00);
    swig_setiv("GFLc::GFL_RIGHT", (long) 0x01);
    swig_setiv("GFLc::GFL_TOP", (long) 0x00);
    swig_setiv("GFLc::GFL_BOTTOM", (long) 0x10);
    swig_setiv("GFLc::GFL_TOP_LEFT", (long) (0x00|0x00));
    swig_setiv("GFLc::GFL_BOTTOM_LEFT", (long) (0x10|0x00));
    swig_setiv("GFLc::GFL_TOP_RIGHT", (long) (0x00|0x01));
    swig_setiv("GFLc::GFL_BOTTOM_RIGHT", (long) (0x10|0x01));
    swig_setiv("GFLc::GFL_NO_COMPRESSION", (long) 0);
    swig_setiv("GFLc::GFL_RLE", (long) 1);
    swig_setiv("GFLc::GFL_LZW", (long) 2);
    swig_setiv("GFLc::GFL_JPEG", (long) 3);
    swig_setiv("GFLc::GFL_ZIP", (long) 4);
    swig_setiv("GFLc::GFL_SGI_RLE", (long) 5);
    swig_setiv("GFLc::GFL_CCITT_RLE", (long) 6);
    swig_setiv("GFLc::GFL_CCITT_FAX3", (long) 7);
    swig_setiv("GFLc::GFL_CCITT_FAX3_2D", (long) 8);
    swig_setiv("GFLc::GFL_CCITT_FAX4", (long) 9);
    swig_setiv("GFLc::GFL_WAVELET", (long) 10);
    swig_setiv("GFLc::GFL_LZW_PREDICTOR", (long) 11);
    swig_setiv("GFLc::GFL_UNKNOWN_COMPRESSION", (long) 255);
    swig_setiv("GFLc::GFL_BINARY", (long) 0x0001);
    swig_setiv("GFLc::GFL_GREY", (long) 0x0002);
    swig_setiv("GFLc::GFL_COLORS", (long) 0x0004);
    swig_setiv("GFLc::GFL_RGB", (long) 0x0010);
    swig_setiv("GFLc::GFL_RGBA", (long) 0x0020);
    swig_setiv("GFLc::GFL_BGR", (long) 0x0040);
    swig_setiv("GFLc::GFL_ABGR", (long) 0x0080);
    swig_setiv("GFLc::GFL_TRUECOLORS", (long) (0x0010|0x0020|0x0040|0x0080));
    swig_setiv("GFLc::GFL_CORDER_INTERLEAVED", (long) 0);
    swig_setiv("GFLc::GFL_CORDER_SEQUENTIAL", (long) 1);
    swig_setiv("GFLc::GFL_CORDER_SEPARATE", (long) 2);
    swig_setiv("GFLc::GFL_CTYPE_GREYSCALE", (long) 0);
    swig_setiv("GFLc::GFL_CTYPE_RGB", (long) 1);
    swig_setiv("GFLc::GFL_CTYPE_BGR", (long) 2);
    swig_setiv("GFLc::GFL_CTYPE_RGBA", (long) 3);
    swig_setiv("GFLc::GFL_CTYPE_ABGR", (long) 4);
    swig_setiv("GFLc::GFL_CTYPE_CMY", (long) 5);
    swig_setiv("GFLc::GFL_CTYPE_CMYK", (long) 6);
    swig_setiv("GFLc::GFL_LOAD_SKIP_ALPHA", (long) 0x0001);
    swig_setiv("GFLc::GFL_LOAD_IGNORE_READ_ERROR", (long) 0x0002);
    swig_setiv("GFLc::GFL_SAVE_REPLACE_EXTENSION", (long) 0x0001);
    swig_setiv("GFLc::GFL_SAVE_WANT_FILENAME", (long) 0x0002);
    swig_setiv("GFLc::GFL_READ", (long) 0x01);
    swig_setiv("GFLc::GFL_WRITE", (long) 0x02);
    swig_setiv("GFLc::GFL_RESIZE_QUICK", (long) 0);
    swig_setiv("GFLc::GFL_RESIZE_BILINEAR", (long) 1);
    swig_setiv("GFLc::GFL_MODE_TO_BINARY", (long) 1);
    swig_setiv("GFLc::GFL_MODE_TO_4GREY", (long) 2);
    swig_setiv("GFLc::GFL_MODE_TO_8GREY", (long) 3);
    swig_setiv("GFLc::GFL_MODE_TO_16GREY", (long) 4);
    swig_setiv("GFLc::GFL_MODE_TO_32GREY", (long) 5);
    swig_setiv("GFLc::GFL_MODE_TO_64GREY", (long) 6);
    swig_setiv("GFLc::GFL_MODE_TO_128GREY", (long) 7);
    swig_setiv("GFLc::GFL_MODE_TO_216GREY", (long) 8);
    swig_setiv("GFLc::GFL_MODE_TO_256GREY", (long) 9);
    swig_setiv("GFLc::GFL_MODE_TO_8COLORS", (long) 12);
    swig_setiv("GFLc::GFL_MODE_TO_16COLORS", (long) 13);
    swig_setiv("GFLc::GFL_MODE_TO_32COLORS", (long) 14);
    swig_setiv("GFLc::GFL_MODE_TO_64COLORS", (long) 15);
    swig_setiv("GFLc::GFL_MODE_TO_128COLORS", (long) 16);
    swig_setiv("GFLc::GFL_MODE_TO_216COLORS", (long) 17);
    swig_setiv("GFLc::GFL_MODE_TO_256COLORS", (long) 18);
    swig_setiv("GFLc::GFL_MODE_TO_TRUE_COLORS", (long) 19);
    swig_setiv("GFLc::GFL_MODE_NO_DITHER", (long) 0);
    swig_setiv("GFLc::GFL_MODE_PATTERN_DITHER", (long) 1);
    swig_setiv("GFLc::GFL_MODE_HALTONE45_DITHER", (long) 2);
    swig_setiv("GFLc::GFL_MODE_HALTONE90_DITHER", (long) 3);
    swig_setiv("GFLc::GFL_MODE_ADAPTIVE", (long) 4);
    swig_setiv("GFLc::GFL_MODE_FLOYD_STEINBERG", (long) 5);
    XSRETURN(1);
}
#ifdef __cplusplus
extern "C"
#endif
XS(SWIG_init) {
	 dXSARGS;
	 char *file = __FILE__;
	 cv = cv; items = items;
	 newXS("GFLc::var_GFL_init", _wrap_perl5_GFL_var_init, file);
	 newXS("GFLc::gflMemoryAlloc", _wrap_gflMemoryAlloc, file);
	 newXS("GFLc::gflMemoryRealloc", _wrap_gflMemoryRealloc, file);
	 newXS("GFLc::gflMemoryFree", _wrap_gflMemoryFree, file);
	 newXS("GFLc::gflGetVersion", _wrap_gflGetVersion, file);
	 newXS("GFLc::gflGetVersionOfLibformat", _wrap_gflGetVersionOfLibformat, file);
	 newXS("GFLc::gflLibraryInit", _wrap_gflLibraryInit, file);
	 newXS("GFLc::gflLibraryExit", _wrap_gflLibraryExit, file);
	 newXS("GFLc::gflEnableLZW", _wrap_gflEnableLZW, file);
	 newXS("GFLc::gflGetNumberOfFormat", _wrap_gflGetNumberOfFormat, file);
	 newXS("GFLc::gflGetFormatIndexByName", _wrap_gflGetFormatIndexByName, file);
	 newXS("GFLc::gflGetFormatNameByIndex", _wrap_gflGetFormatNameByIndex, file);
	 newXS("GFLc::gflFormatIsSupported", _wrap_gflFormatIsSupported, file);
	 newXS("GFLc::gflFormatIsWritableByIndex", _wrap_gflFormatIsWritableByIndex, file);
	 newXS("GFLc::gflFormatIsWritableByName", _wrap_gflFormatIsWritableByName, file);
	 newXS("GFLc::gflFormatIsReadableByIndex", _wrap_gflFormatIsReadableByIndex, file);
	 newXS("GFLc::gflFormatIsReadableByName", _wrap_gflFormatIsReadableByName, file);
	 newXS("GFLc::gflGetDefaultFormatSuffixByIndex", _wrap_gflGetDefaultFormatSuffixByIndex, file);
	 newXS("GFLc::gflGetDefaultFormatSuffixByName", _wrap_gflGetDefaultFormatSuffixByName, file);
	 newXS("GFLc::gflGetFormatDescriptionByIndex", _wrap_gflGetFormatDescriptionByIndex, file);
	 newXS("GFLc::gflGetFormatDescriptionByName", _wrap_gflGetFormatDescriptionByName, file);
	 newXS("GFLc::gflGetFormatInformationByName", _wrap_gflGetFormatInformationByName, file);
	 newXS("GFLc::gflGetFormatInformationByIndex", _wrap_gflGetFormatInformationByIndex, file);
	 newXS("GFLc::gflGetErrorString", _wrap_gflGetErrorString, file);
	 newXS("GFLc::gflGetFileInformation", _wrap_gflGetFileInformation, file);
	 newXS("GFLc::gflGetDefaultLoadParams", _wrap_gflGetDefaultLoadParams, file);
	 newXS("GFLc::gflLoadBitmap", _wrap_gflLoadBitmap, file);
	 newXS("GFLc::gflLoadBitmapFromHandle", _wrap_gflLoadBitmapFromHandle, file);
	 newXS("GFLc::gflGetDefaultPreviewParams", _wrap_gflGetDefaultPreviewParams, file);
	 newXS("GFLc::gflLoadPreview", _wrap_gflLoadPreview, file);
	 newXS("GFLc::gflLoadPreviewFromHandle", _wrap_gflLoadPreviewFromHandle, file);
	 newXS("GFLc::gflGetDefaultSaveParams", _wrap_gflGetDefaultSaveParams, file);
	 newXS("GFLc::gflSaveBitmap", _wrap_gflSaveBitmap, file);
	 newXS("GFLc::gflSaveBitmapFromHandle", _wrap_gflSaveBitmapFromHandle, file);
	 newXS("GFLc::gflAllockBitmap", _wrap_gflAllockBitmap, file);
	 newXS("GFLc::gflFreeBitmap", _wrap_gflFreeBitmap, file);
	 newXS("GFLc::gflFreeBitmapData", _wrap_gflFreeBitmapData, file);
	 newXS("GFLc::gflResize", _wrap_gflResize, file);
	 newXS("GFLc::gflChangeColorDepth", _wrap_gflChangeColorDepth, file);
	 newXS("GFLc::gflFlipVertical", _wrap_gflFlipVertical, file);
	 newXS("GFLc::gflFlipHorizontal", _wrap_gflFlipHorizontal, file);
	 newXS("GFLc::gflCrop", _wrap_gflCrop, file);
	 newXS("GFLc::gflNegative", _wrap_gflNegative, file);
	 newXS("GFLc::gflBrightness", _wrap_gflBrightness, file);
	 newXS("GFLc::gflContrast", _wrap_gflContrast, file);
	 newXS("GFLc::gflGamma", _wrap_gflGamma, file);
	 newXS("GFLc::gflRotate", _wrap_gflRotate, file);
	 newXS("GFLc::gflAverage", _wrap_gflAverage, file);
	 newXS("GFLc::gflSoften", _wrap_gflSoften, file);
	 newXS("GFLc::gflBlur", _wrap_gflBlur, file);
	 newXS("GFLc::gflGaussianBlur", _wrap_gflGaussianBlur, file);
	 newXS("GFLc::gflMaximum", _wrap_gflMaximum, file);
	 newXS("GFLc::gflMinimum", _wrap_gflMinimum, file);
	 newXS("GFLc::gflMedianBox", _wrap_gflMedianBox, file);
	 newXS("GFLc::gflMedianCross", _wrap_gflMedianCross, file);
	 newXS("GFLc::gflSharpen", _wrap_gflSharpen, file);
	 newXS("GFLc::gflGetNumberOfColorsUsed", _wrap_gflGetNumberOfColorsUsed, file);
	 newXS("GFLc::free_GflStruct", _wrap_free_GflStruct, file);
	 newXS("GFLc::new_FileInformation", _wrap_new_FileInformation, file);
	 newXS("GFLc::new_FormatInformation", _wrap_new_FormatInformation, file);
	 newXS("GFLc::new_LoadParams", _wrap_new_LoadParams, file);
	 newXS("GFLc::new_SaveParams", _wrap_new_SaveParams, file);
	 newXS("GFLc::new_Rect", _wrap_new_Rect, file);
	 newXS("GFLc::new_BitmapPtr", _wrap_new_BitmapPtr, file);
	 newXS("GFLc::addr_of_Bitmap", _wrap_addr_of_Bitmap, file);
	 newXS("GFLc::GFL_COLORMAP_Red_get", _wrap_GFL_COLORMAP_Red_get, file);
	 newXS("GFLc::GFL_COLORMAP_Green_get", _wrap_GFL_COLORMAP_Green_get, file);
	 newXS("GFLc::GFL_COLORMAP_Blue_get", _wrap_GFL_COLORMAP_Blue_get, file);
	 newXS("GFLc::GFL_BITMAP_Type_set", _wrap_GFL_BITMAP_Type_set, file);
	 newXS("GFLc::GFL_BITMAP_Type_get", _wrap_GFL_BITMAP_Type_get, file);
	 newXS("GFLc::GFL_BITMAP_Origin_set", _wrap_GFL_BITMAP_Origin_set, file);
	 newXS("GFLc::GFL_BITMAP_Origin_get", _wrap_GFL_BITMAP_Origin_get, file);
	 newXS("GFLc::GFL_BITMAP_Width_set", _wrap_GFL_BITMAP_Width_set, file);
	 newXS("GFLc::GFL_BITMAP_Width_get", _wrap_GFL_BITMAP_Width_get, file);
	 newXS("GFLc::GFL_BITMAP_Height_set", _wrap_GFL_BITMAP_Height_set, file);
	 newXS("GFLc::GFL_BITMAP_Height_get", _wrap_GFL_BITMAP_Height_get, file);
	 newXS("GFLc::GFL_BITMAP_BytesPerLine_set", _wrap_GFL_BITMAP_BytesPerLine_set, file);
	 newXS("GFLc::GFL_BITMAP_BytesPerLine_get", _wrap_GFL_BITMAP_BytesPerLine_get, file);
	 newXS("GFLc::GFL_BITMAP_BytesPerPixel_set", _wrap_GFL_BITMAP_BytesPerPixel_set, file);
	 newXS("GFLc::GFL_BITMAP_BytesPerPixel_get", _wrap_GFL_BITMAP_BytesPerPixel_get, file);
	 newXS("GFLc::GFL_BITMAP_BitsPerComponent_set", _wrap_GFL_BITMAP_BitsPerComponent_set, file);
	 newXS("GFLc::GFL_BITMAP_BitsPerComponent_get", _wrap_GFL_BITMAP_BitsPerComponent_get, file);
	 newXS("GFLc::GFL_BITMAP_Xdpi_set", _wrap_GFL_BITMAP_Xdpi_set, file);
	 newXS("GFLc::GFL_BITMAP_Xdpi_get", _wrap_GFL_BITMAP_Xdpi_get, file);
	 newXS("GFLc::GFL_BITMAP_Ydpi_set", _wrap_GFL_BITMAP_Ydpi_set, file);
	 newXS("GFLc::GFL_BITMAP_Ydpi_get", _wrap_GFL_BITMAP_Ydpi_get, file);
	 newXS("GFLc::GFL_BITMAP_TransparentIndex_set", _wrap_GFL_BITMAP_TransparentIndex_set, file);
	 newXS("GFLc::GFL_BITMAP_TransparentIndex_get", _wrap_GFL_BITMAP_TransparentIndex_get, file);
	 newXS("GFLc::GFL_BITMAP_ColorUsed_set", _wrap_GFL_BITMAP_ColorUsed_set, file);
	 newXS("GFLc::GFL_BITMAP_ColorUsed_get", _wrap_GFL_BITMAP_ColorUsed_get, file);
	 newXS("GFLc::GFL_BITMAP_ColorMap_set", _wrap_GFL_BITMAP_ColorMap_set, file);
	 newXS("GFLc::GFL_BITMAP_ColorMap_get", _wrap_GFL_BITMAP_ColorMap_get, file);
	 newXS("GFLc::GFL_BITMAP_Data_set", _wrap_GFL_BITMAP_Data_set, file);
	 newXS("GFLc::GFL_BITMAP_Data_get", _wrap_GFL_BITMAP_Data_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Flags_set", _wrap_GFL_LOAD_PARAMS_Flags_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Flags_get", _wrap_GFL_LOAD_PARAMS_Flags_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_FormatIndex_set", _wrap_GFL_LOAD_PARAMS_FormatIndex_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_FormatIndex_get", _wrap_GFL_LOAD_PARAMS_FormatIndex_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ImageWanted_set", _wrap_GFL_LOAD_PARAMS_ImageWanted_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ImageWanted_get", _wrap_GFL_LOAD_PARAMS_ImageWanted_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Origin_set", _wrap_GFL_LOAD_PARAMS_Origin_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Origin_get", _wrap_GFL_LOAD_PARAMS_Origin_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ColorModel_set", _wrap_GFL_LOAD_PARAMS_ColorModel_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ColorModel_get", _wrap_GFL_LOAD_PARAMS_ColorModel_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_LinePadding_set", _wrap_GFL_LOAD_PARAMS_LinePadding_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_LinePadding_get", _wrap_GFL_LOAD_PARAMS_LinePadding_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Width_set", _wrap_GFL_LOAD_PARAMS_Width_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Width_get", _wrap_GFL_LOAD_PARAMS_Width_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Height_set", _wrap_GFL_LOAD_PARAMS_Height_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Height_get", _wrap_GFL_LOAD_PARAMS_Height_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Offset_set", _wrap_GFL_LOAD_PARAMS_Offset_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Offset_get", _wrap_GFL_LOAD_PARAMS_Offset_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ChannelOrder_set", _wrap_GFL_LOAD_PARAMS_ChannelOrder_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ChannelOrder_get", _wrap_GFL_LOAD_PARAMS_ChannelOrder_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ChannelType_set", _wrap_GFL_LOAD_PARAMS_ChannelType_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_ChannelType_get", _wrap_GFL_LOAD_PARAMS_ChannelType_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_PcdBase_set", _wrap_GFL_LOAD_PARAMS_PcdBase_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_PcdBase_get", _wrap_GFL_LOAD_PARAMS_PcdBase_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_get", _wrap_GFL_LOAD_PARAMS_Callbacks_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Read_set", _wrap_GFL_LOAD_PARAMS_Callbacks_Read_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Read_get", _wrap_GFL_LOAD_PARAMS_Callbacks_Read_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Tell_set", _wrap_GFL_LOAD_PARAMS_Callbacks_Tell_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Tell_get", _wrap_GFL_LOAD_PARAMS_Callbacks_Tell_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Seek_set", _wrap_GFL_LOAD_PARAMS_Callbacks_Seek_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Seek_get", _wrap_GFL_LOAD_PARAMS_Callbacks_Seek_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Alloc_set", _wrap_GFL_LOAD_PARAMS_Callbacks_Alloc_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Alloc_get", _wrap_GFL_LOAD_PARAMS_Callbacks_Alloc_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Free_set", _wrap_GFL_LOAD_PARAMS_Callbacks_Free_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_Free_get", _wrap_GFL_LOAD_PARAMS_Callbacks_Free_get, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_AllocParam_set", _wrap_GFL_LOAD_PARAMS_Callbacks_AllocParam_set, file);
	 newXS("GFLc::GFL_LOAD_PARAMS_Callbacks_AllocParam_get", _wrap_GFL_LOAD_PARAMS_Callbacks_AllocParam_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Flags_set", _wrap_GFL_SAVE_PARAMS_Flags_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Flags_get", _wrap_GFL_SAVE_PARAMS_Flags_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_FormatIndex_set", _wrap_GFL_SAVE_PARAMS_FormatIndex_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_FormatIndex_get", _wrap_GFL_SAVE_PARAMS_FormatIndex_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Compression_set", _wrap_GFL_SAVE_PARAMS_Compression_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Compression_get", _wrap_GFL_SAVE_PARAMS_Compression_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Quality_set", _wrap_GFL_SAVE_PARAMS_Quality_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Quality_get", _wrap_GFL_SAVE_PARAMS_Quality_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_CompressionLevel_set", _wrap_GFL_SAVE_PARAMS_CompressionLevel_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_CompressionLevel_get", _wrap_GFL_SAVE_PARAMS_CompressionLevel_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Interlaced_set", _wrap_GFL_SAVE_PARAMS_Interlaced_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Interlaced_get", _wrap_GFL_SAVE_PARAMS_Interlaced_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Progressive_set", _wrap_GFL_SAVE_PARAMS_Progressive_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Progressive_get", _wrap_GFL_SAVE_PARAMS_Progressive_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Offset_set", _wrap_GFL_SAVE_PARAMS_Offset_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Offset_get", _wrap_GFL_SAVE_PARAMS_Offset_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_ChannelOrder_set", _wrap_GFL_SAVE_PARAMS_ChannelOrder_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_ChannelOrder_get", _wrap_GFL_SAVE_PARAMS_ChannelOrder_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_ChannelType_set", _wrap_GFL_SAVE_PARAMS_ChannelType_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_ChannelType_get", _wrap_GFL_SAVE_PARAMS_ChannelType_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_get", _wrap_GFL_SAVE_PARAMS_Callbacks_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Write_set", _wrap_GFL_SAVE_PARAMS_Callbacks_Write_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Write_get", _wrap_GFL_SAVE_PARAMS_Callbacks_Write_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Tell_set", _wrap_GFL_SAVE_PARAMS_Callbacks_Tell_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Tell_get", _wrap_GFL_SAVE_PARAMS_Callbacks_Tell_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Seek_set", _wrap_GFL_SAVE_PARAMS_Callbacks_Seek_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Seek_get", _wrap_GFL_SAVE_PARAMS_Callbacks_Seek_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Alloc_set", _wrap_GFL_SAVE_PARAMS_Callbacks_Alloc_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Alloc_get", _wrap_GFL_SAVE_PARAMS_Callbacks_Alloc_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Free_set", _wrap_GFL_SAVE_PARAMS_Callbacks_Free_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_Free_get", _wrap_GFL_SAVE_PARAMS_Callbacks_Free_get, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_AllocParam_set", _wrap_GFL_SAVE_PARAMS_Callbacks_AllocParam_set, file);
	 newXS("GFLc::GFL_SAVE_PARAMS_Callbacks_AllocParam_get", _wrap_GFL_SAVE_PARAMS_Callbacks_AllocParam_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Type_set", _wrap_GFL_FILE_INFORMATION_Type_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Type_get", _wrap_GFL_FILE_INFORMATION_Type_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Width_set", _wrap_GFL_FILE_INFORMATION_Width_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Width_get", _wrap_GFL_FILE_INFORMATION_Width_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Height_set", _wrap_GFL_FILE_INFORMATION_Height_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Height_get", _wrap_GFL_FILE_INFORMATION_Height_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_FormatIndex_set", _wrap_GFL_FILE_INFORMATION_FormatIndex_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_FormatIndex_get", _wrap_GFL_FILE_INFORMATION_FormatIndex_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_FormatName_get", _wrap_GFL_FILE_INFORMATION_FormatName_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Description_get", _wrap_GFL_FILE_INFORMATION_Description_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Xdpi_set", _wrap_GFL_FILE_INFORMATION_Xdpi_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Xdpi_get", _wrap_GFL_FILE_INFORMATION_Xdpi_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Ydpi_set", _wrap_GFL_FILE_INFORMATION_Ydpi_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Ydpi_get", _wrap_GFL_FILE_INFORMATION_Ydpi_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_BitsPerPlane_set", _wrap_GFL_FILE_INFORMATION_BitsPerPlane_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_BitsPerPlane_get", _wrap_GFL_FILE_INFORMATION_BitsPerPlane_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_NumberOfPlanes_set", _wrap_GFL_FILE_INFORMATION_NumberOfPlanes_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_NumberOfPlanes_get", _wrap_GFL_FILE_INFORMATION_NumberOfPlanes_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_BytesPerPlane_set", _wrap_GFL_FILE_INFORMATION_BytesPerPlane_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_BytesPerPlane_get", _wrap_GFL_FILE_INFORMATION_BytesPerPlane_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_NumberOfImages_set", _wrap_GFL_FILE_INFORMATION_NumberOfImages_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_NumberOfImages_get", _wrap_GFL_FILE_INFORMATION_NumberOfImages_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_FileSize_set", _wrap_GFL_FILE_INFORMATION_FileSize_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_FileSize_get", _wrap_GFL_FILE_INFORMATION_FileSize_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Origin_set", _wrap_GFL_FILE_INFORMATION_Origin_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Origin_get", _wrap_GFL_FILE_INFORMATION_Origin_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Compression_set", _wrap_GFL_FILE_INFORMATION_Compression_set, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_Compression_get", _wrap_GFL_FILE_INFORMATION_Compression_get, file);
	 newXS("GFLc::GFL_FILE_INFORMATION_CompressionDescription_get", _wrap_GFL_FILE_INFORMATION_CompressionDescription_get, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_Index_set", _wrap_GFL_FORMAT_INFORMATION_Index_set, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_Index_get", _wrap_GFL_FORMAT_INFORMATION_Index_get, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_Name_get", _wrap_GFL_FORMAT_INFORMATION_Name_get, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_Description_get", _wrap_GFL_FORMAT_INFORMATION_Description_get, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_Status_set", _wrap_GFL_FORMAT_INFORMATION_Status_set, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_Status_get", _wrap_GFL_FORMAT_INFORMATION_Status_get, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_NumberOfExtension_set", _wrap_GFL_FORMAT_INFORMATION_NumberOfExtension_set, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_NumberOfExtension_get", _wrap_GFL_FORMAT_INFORMATION_NumberOfExtension_get, file);
	 newXS("GFLc::GFL_FORMAT_INFORMATION_Extension_get", _wrap_GFL_FORMAT_INFORMATION_Extension_get, file);
	 newXS("GFLc::GFL_RECT_x_set", _wrap_GFL_RECT_x_set, file);
	 newXS("GFLc::GFL_RECT_x_get", _wrap_GFL_RECT_x_get, file);
	 newXS("GFLc::GFL_RECT_y_set", _wrap_GFL_RECT_y_set, file);
	 newXS("GFLc::GFL_RECT_y_get", _wrap_GFL_RECT_y_get, file);
	 newXS("GFLc::GFL_RECT_w_set", _wrap_GFL_RECT_w_set, file);
	 newXS("GFLc::GFL_RECT_w_get", _wrap_GFL_RECT_w_get, file);
	 newXS("GFLc::GFL_RECT_h_set", _wrap_GFL_RECT_h_set, file);
	 newXS("GFLc::GFL_RECT_h_get", _wrap_GFL_RECT_h_get, file);
{
   int i;
   for (i = 0; _swig_mapping[i].n1; i++)
        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
}
	 ST(0) = &PL_sv_yes;
	 XSRETURN(1);
}