git.saurik.com Git - wxWidgets.git/blame_incremental - wxPython/contrib/animate/mac/animate

... / ...

Commit	Line	Data
	1	/* ----------------------------------------------------------------------------
	2	* This file was automatically generated by SWIG (http://www.swig.org).
	3	* Version 1.3.24
	4	*
	5	* This file is not intended to be easily readable and contains a number of
	6	* coding conventions designed to improve portability and efficiency. Do not make
	7	* changes to this file unless you know what you are doing--modify the SWIG
	8	* interface file instead.
	9	* ----------------------------------------------------------------------------- */
	10
	11	#define SWIGPYTHON
	12
	13	#ifdef __cplusplus
	14	template<class T> class SwigValueWrapper {
	15	T *tt;
	16	public:
	17	SwigValueWrapper() : tt(0) { }
	18	SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
	19	SwigValueWrapper(const T& t) : tt(new T(t)) { }
	20	~SwigValueWrapper() { delete tt; }
	21	SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
	22	operator T&() const { return *tt; }
	23	T *operator&() { return tt; }
	24	private:
	25	SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
	26	};
	27	#endif
	28
	29
	30	#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
	31	# if defined(__SUNPRO_CC)
	32	# define SWIG_TEMPLATE_DISAMBIGUATOR template
	33	# else
	34	# define SWIG_TEMPLATE_DISAMBIGUATOR
	35	# endif
	36	#endif
	37
	38
	39	#include <Python.h>
	40
	41	/***********************************************************************
	42	* swigrun.swg
	43	*
	44	* This file contains generic CAPI SWIG runtime support for pointer
	45	* type checking.
	46	*
	47	************************************************************************/
	48
	49	/* This should only be incremented when either the layout of swig_type_info changes,
	50	or for whatever reason, the runtime changes incompatibly */
	51	#define SWIG_RUNTIME_VERSION "1"
	52
	53	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
	54	#ifdef SWIG_TYPE_TABLE
	55	#define SWIG_QUOTE_STRING(x) #x
	56	#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
	57	#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
	58	#else
	59	#define SWIG_TYPE_TABLE_NAME
	60	#endif
	61
	62	#include <string.h>
	63
	64	#ifndef SWIGINLINE
	65	#if defined(__cplusplus) \|\| (defined(__GNUC__) && !defined(__STRICT_ANSI__))
	66	# define SWIGINLINE inline
	67	#else
	68	# define SWIGINLINE
	69	#endif
	70	#endif
	71
	72	/*
	73	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
	74	creating a static or dynamic library from the swig runtime code.
	75	In 99.9% of the cases, swig just needs to declare them as 'static'.
	76
	77	But only do this if is strictly necessary, ie, if you have problems
	78	with your compiler or so.
	79	*/
	80	#ifndef SWIGRUNTIME
	81	#define SWIGRUNTIME static
	82	#endif
	83	#ifndef SWIGRUNTIMEINLINE
	84	#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
	85	#endif
	86
	87	#ifdef __cplusplus
	88	extern "C" {
	89	#endif
	90
	91	typedef void (swig_converter_func)(void *);
	92	typedef struct swig_type_info (swig_dycast_func)(void **);
	93
	94	typedef struct swig_type_info {
	95	const char *name;
	96	swig_converter_func converter;
	97	const char *str;
	98	void *clientdata;
	99	swig_dycast_func dcast;
	100	struct swig_type_info *next;
	101	struct swig_type_info *prev;
	102	} swig_type_info;
	103
	104	/*
	105	Compare two type names skipping the space characters, therefore
	106	"char" == "char " and "Class<int>" == "Class<int >", etc.
	107
	108	Return 0 when the two name types are equivalent, as in
	109	strncmp, but skipping ' '.
	110	*/
	111	SWIGRUNTIME int
	112	SWIG_TypeNameComp(const char f1, const char l1,
	113	const char f2, const char l2) {
	114	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
	115	while ((*f1 == ' ') && (f1 != l1)) ++f1;
	116	while ((*f2 == ' ') && (f2 != l2)) ++f2;
	117	if (f1 != f2) return f1 - f2;
	118	}
	119	return (l1 - f1) - (l2 - f2);
	120	}
	121
	122	/*
	123	Check type equivalence in a name list like <name1>\|<name2>\|...
	124	*/
	125	SWIGRUNTIME int
	126	SWIG_TypeEquiv(const char nb, const char tb) {
	127	int equiv = 0;
	128	const char* te = tb + strlen(tb);
	129	const char* ne = nb;
	130	while (!equiv && *ne) {
	131	for (nb = ne; *ne; ++ne) {
	132	if (*ne == '\|') break;
	133	}
	134	equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
	135	if (*ne) ++ne;
	136	}
	137	return equiv;
	138	}
	139
	140	/*
	141	Register a type mapping with the type-checking
	142	*/
	143	SWIGRUNTIME swig_type_info *
	144	SWIG_TypeRegisterTL(swig_type_info *tl, swig_type_info ti) {
	145	swig_type_info tc, head, ret, next;
	146	/* Check to see if this type has already been registered */
	147	tc = *tl;
	148	while (tc) {
	149	/* check simple type equivalence */
	150	int typeequiv = (strcmp(tc->name, ti->name) == 0);
	151	/* check full type equivalence, resolving typedefs */
	152	if (!typeequiv) {
	153	/* only if tc is not a typedef (no '\|' on it) */
	154	if (tc->str && ti->str && !strstr(tc->str,"\|")) {
	155	typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
	156	}
	157	}
	158	if (typeequiv) {
	159	/* Already exists in the table. Just add additional types to the list */
	160	if (ti->clientdata) tc->clientdata = ti->clientdata;
	161	head = tc;
	162	next = tc->next;
	163	goto l1;
	164	}
	165	tc = tc->prev;
	166	}
	167	head = ti;
	168	next = 0;
	169
	170	/* Place in list */
	171	ti->prev = *tl;
	172	*tl = ti;
	173
	174	/* Build linked lists */
	175	l1:
	176	ret = head;
	177	tc = ti + 1;
	178	/* Patch up the rest of the links */
	179	while (tc->name) {
	180	head->next = tc;
	181	tc->prev = head;
	182	head = tc;
	183	tc++;
	184	}
	185	if (next) next->prev = head;
	186	head->next = next;
	187
	188	return ret;
	189	}
	190
	191	/*
	192	Check the typename
	193	*/
	194	SWIGRUNTIME swig_type_info *
	195	SWIG_TypeCheck(const char c, swig_type_info ty) {
	196	swig_type_info *s;
	197	if (!ty) return 0; /* Void pointer */
	198	s = ty->next; /* First element always just a name */
	199	do {
	200	if (strcmp(s->name,c) == 0) {
	201	if (s == ty->next) return s;
	202	/* Move s to the top of the linked list */
	203	s->prev->next = s->next;
	204	if (s->next) {
	205	s->next->prev = s->prev;
	206	}
	207	/* Insert s as second element in the list */
	208	s->next = ty->next;
	209	if (ty->next) ty->next->prev = s;
	210	ty->next = s;
	211	s->prev = ty;
	212	return s;
	213	}
	214	s = s->next;
	215	} while (s && (s != ty->next));
	216	return 0;
	217	}
	218
	219	/*
	220	Cast a pointer up an inheritance hierarchy
	221	*/
	222	SWIGRUNTIMEINLINE void *
	223	SWIG_TypeCast(swig_type_info ty, void ptr) {
	224	return ((!ty) \|\| (!ty->converter)) ? ptr : (*ty->converter)(ptr);
	225	}
	226
	227	/*
	228	Dynamic pointer casting. Down an inheritance hierarchy
	229	*/
	230	SWIGRUNTIME swig_type_info *
	231	SWIG_TypeDynamicCast(swig_type_info ty, void *ptr) {
	232	swig_type_info *lastty = ty;
	233	if (!ty \|\| !ty->dcast) return ty;
	234	while (ty && (ty->dcast)) {
	235	ty = (*ty->dcast)(ptr);
	236	if (ty) lastty = ty;
	237	}
	238	return lastty;
	239	}
	240
	241	/*
	242	Return the name associated with this type
	243	*/
	244	SWIGRUNTIMEINLINE const char *
	245	SWIG_TypeName(const swig_type_info *ty) {
	246	return ty->name;
	247	}
	248
	249	/*
	250	Return the pretty name associated with this type,
	251	that is an unmangled type name in a form presentable to the user.
	252	*/
	253	SWIGRUNTIME const char *
	254	SWIG_TypePrettyName(const swig_type_info *type) {
	255	/* The "str" field contains the equivalent pretty names of the
	256	type, separated by vertical-bar characters. We choose
	257	to print the last name, as it is often (?) the most
	258	specific. */
	259	if (type->str != NULL) {
	260	const char *last_name = type->str;
	261	const char *s;
	262	for (s = type->str; *s; s++)
	263	if (*s == '\|') last_name = s+1;
	264	return last_name;
	265	}
	266	else
	267	return type->name;
	268	}
	269
	270	/*
	271	Search for a swig_type_info structure
	272	*/
	273	SWIGRUNTIME swig_type_info *
	274	SWIG_TypeQueryTL(swig_type_info tl, const char name) {
	275	swig_type_info *ty = tl;
	276	while (ty) {
	277	if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
	278	if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
	279	ty = ty->prev;
	280	}
	281	return 0;
	282	}
	283
	284	/*
	285	Set the clientdata field for a type
	286	*/
	287	SWIGRUNTIME void
	288	SWIG_TypeClientDataTL(swig_type_info tl, swig_type_info ti, void *clientdata) {
	289	swig_type_info tc, equiv;
	290	if (ti->clientdata) return;
	291	/* if (ti->clientdata == clientdata) return; */
	292	ti->clientdata = clientdata;
	293	equiv = ti->next;
	294	while (equiv) {
	295	if (!equiv->converter) {
	296	tc = tl;
	297	while (tc) {
	298	if ((strcmp(tc->name, equiv->name) == 0))
	299	SWIG_TypeClientDataTL(tl,tc,clientdata);
	300	tc = tc->prev;
	301	}
	302	}
	303	equiv = equiv->next;
	304	}
	305	}
	306
	307	/*
	308	Pack binary data into a string
	309	*/
	310	SWIGRUNTIME char *
	311	SWIG_PackData(char c, void ptr, size_t sz) {
	312	static char hex[17] = "0123456789abcdef";
	313	unsigned char u = (unsigned char ) ptr;
	314	const unsigned char *eu = u + sz;
	315	register unsigned char uu;
	316	for (; u != eu; ++u) {
	317	uu = *u;
	318	*(c++) = hex[(uu & 0xf0) >> 4];
	319	*(c++) = hex[uu & 0xf];
	320	}
	321	return c;
	322	}
	323
	324	/*
	325	Unpack binary data from a string
	326	*/
	327	SWIGRUNTIME const char *
	328	SWIG_UnpackData(const char c, void ptr, size_t sz) {
	329	register unsigned char u = (unsigned char ) ptr;
	330	register const unsigned char *eu = u + sz;
	331	for (; u != eu; ++u) {
	332	register int d = *(c++);
	333	register unsigned char uu = 0;
	334	if ((d >= '0') && (d <= '9'))
	335	uu = ((d - '0') << 4);
	336	else if ((d >= 'a') && (d <= 'f'))
	337	uu = ((d - ('a'-10)) << 4);
	338	else
	339	return (char *) 0;
	340	d = *(c++);
	341	if ((d >= '0') && (d <= '9'))
	342	uu \|= (d - '0');
	343	else if ((d >= 'a') && (d <= 'f'))
	344	uu \|= (d - ('a'-10));
	345	else
	346	return (char *) 0;
	347	*u = uu;
	348	}
	349	return c;
	350	}
	351
	352	/*
	353	This function will propagate the clientdata field of type to any new
	354	swig_type_info structures that have been added into the list of
	355	equivalent types. It is like calling SWIG_TypeClientData(type,
	356	clientdata) a second time.
	357	*/
	358	SWIGRUNTIME void
	359	SWIG_PropagateClientDataTL(swig_type_info tl, swig_type_info type) {
	360	swig_type_info *equiv = type->next;
	361	swig_type_info *tc;
	362	if (!type->clientdata) return;
	363	while (equiv) {
	364	if (!equiv->converter) {
	365	tc = tl;
	366	while (tc) {
	367	if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
	368	SWIG_TypeClientDataTL(tl,tc, type->clientdata);
	369	tc = tc->prev;
	370	}
	371	}
	372	equiv = equiv->next;
	373	}
	374	}
	375
	376	/*
	377	Pack 'void *' into a string buffer.
	378	*/
	379	SWIGRUNTIME char *
	380	SWIG_PackVoidPtr(char buff, void ptr, const char *name, size_t bsz) {
	381	char *r = buff;
	382	if ((2sizeof(void ) + 2) > bsz) return 0;
	383	*(r++) = '_';
	384	r = SWIG_PackData(r,&ptr,sizeof(void *));
	385	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
	386	strcpy(r,name);
	387	return buff;
	388	}
	389
	390	SWIGRUNTIME const char *
	391	SWIG_UnpackVoidPtr(const char c, void ptr, const char name) {
	392	if (*c != '_') {
	393	if (strcmp(c,"NULL") == 0) {
	394	ptr = (void ) 0;
	395	return name;
	396	} else {
	397	return 0;
	398	}
	399	}
	400	return SWIG_UnpackData(++c,ptr,sizeof(void *));
	401	}
	402
	403	SWIGRUNTIME char *
	404	SWIG_PackDataName(char buff, void ptr, size_t sz, const char *name, size_t bsz) {
	405	char *r = buff;
	406	size_t lname = (name ? strlen(name) : 0);
	407	if ((2*sz + 2 + lname) > bsz) return 0;
	408	*(r++) = '_';
	409	r = SWIG_PackData(r,ptr,sz);
	410	if (lname) {
	411	strncpy(r,name,lname+1);
	412	} else {
	413	*r = 0;
	414	}
	415	return buff;
	416	}
	417
	418	SWIGRUNTIME const char *
	419	SWIG_UnpackDataName(const char c, void ptr, size_t sz, const char *name) {
	420	if (*c != '_') {
	421	if (strcmp(c,"NULL") == 0) {
	422	memset(ptr,0,sz);
	423	return name;
	424	} else {
	425	return 0;
	426	}
	427	}
	428	return SWIG_UnpackData(++c,ptr,sz);
	429	}
	430
	431	#ifdef __cplusplus
	432	}
	433	#endif
	434
	435	/***********************************************************************
	436	* common.swg
	437	*
	438	* This file contains generic SWIG runtime support for pointer
	439	* type checking as well as a few commonly used macros to control
	440	* external linkage.
	441	*
	442	* Author : David Beazley (beazley@cs.uchicago.edu)
	443	*
	444	* Copyright (c) 1999-2000, The University of Chicago
	445	*
	446	* This file may be freely redistributed without license or fee provided
	447	* this copyright message remains intact.
	448	************************************************************************/
	449
	450
	451	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
	452	# if !defined(STATIC_LINKED)
	453	# define SWIGEXPORT(a) __declspec(dllexport) a
	454	# else
	455	# define SWIGEXPORT(a) a
	456	# endif
	457	#else
	458	# define SWIGEXPORT(a) a
	459	#endif
	460
	461	#ifdef __cplusplus
	462	extern "C" {
	463	#endif
	464
	465
	466	/*************************************************************************/
	467
	468
	469	/* The static type info list */
	470
	471	static swig_type_info *swig_type_list = 0;
	472	static swig_type_info **swig_type_list_handle = &swig_type_list;
	473
	474
	475	/* Register a type mapping with the type-checking */
	476	static swig_type_info *
	477	SWIG_TypeRegister(swig_type_info *ti) {
	478	return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
	479	}
	480
	481	/* Search for a swig_type_info structure */
	482	static swig_type_info *
	483	SWIG_TypeQuery(const char *name) {
	484	return SWIG_TypeQueryTL(*swig_type_list_handle, name);
	485	}
	486
	487	/* Set the clientdata field for a type */
	488	static void
	489	SWIG_TypeClientData(swig_type_info ti, void clientdata) {
	490	SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
	491	}
	492
	493	/* This function will propagate the clientdata field of type to
	494	* any new swig_type_info structures that have been added into the list
	495	* of equivalent types. It is like calling
	496	* SWIG_TypeClientData(type, clientdata) a second time.
	497	*/
	498	static void
	499	SWIG_PropagateClientData(swig_type_info *type) {
	500	SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
	501	}
	502
	503	#ifdef __cplusplus
	504	}
	505	#endif
	506
	507	/* -----------------------------------------------------------------------------
	508	* SWIG API. Portion that goes into the runtime
	509	* ----------------------------------------------------------------------------- */
	510
	511	#ifdef __cplusplus
	512	extern "C" {
	513	#endif
	514
	515	/* -----------------------------------------------------------------------------
	516	* for internal method declarations
	517	* ----------------------------------------------------------------------------- */
	518
	519	#ifndef SWIGINTERN
	520	#define SWIGINTERN static
	521	#endif
	522
	523	#ifndef SWIGINTERNSHORT
	524	#ifdef __cplusplus
	525	#define SWIGINTERNSHORT static inline
	526	#else /* C case */
	527	#define SWIGINTERNSHORT static
	528	#endif /* __cplusplus */
	529	#endif
	530
	531
	532	/*
	533	Exception handling in wrappers
	534	*/
	535	#define SWIG_fail goto fail
	536	#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
	537	#define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
	538	#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
	539	#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
	540	#define SWIG_null_ref(type) SWIG_Python_NullRef(type)
	541
	542	/*
	543	Contract support
	544	*/
	545	#define SWIG_contract_assert(expr, msg) \
	546	if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
	547
	548	/* -----------------------------------------------------------------------------
	549	* Constant declarations
	550	* ----------------------------------------------------------------------------- */
	551
	552	/* Constant Types */
	553	#define SWIG_PY_INT 1
	554	#define SWIG_PY_FLOAT 2
	555	#define SWIG_PY_STRING 3
	556	#define SWIG_PY_POINTER 4
	557	#define SWIG_PY_BINARY 5
	558
	559	/* Constant information structure */
	560	typedef struct swig_const_info {
	561	int type;
	562	char *name;
	563	long lvalue;
	564	double dvalue;
	565	void *pvalue;
	566	swig_type_info **ptype;
	567	} swig_const_info;
	568
	569
	570	/* -----------------------------------------------------------------------------
	571	* Alloc. memory flags
	572	* ----------------------------------------------------------------------------- */
	573	#define SWIG_OLDOBJ 1
	574	#define SWIG_NEWOBJ SWIG_OLDOBJ + 1
	575	#define SWIG_PYSTR SWIG_NEWOBJ + 1
	576
	577	#ifdef __cplusplus
	578	}
	579	#endif
	580
	581
	582	/***********************************************************************
	583	* pyrun.swg
	584	*
	585	* This file contains the runtime support for Python modules
	586	* and includes code for managing global variables and pointer
	587	* type checking.
	588	*
	589	* Author : David Beazley (beazley@cs.uchicago.edu)
	590	************************************************************************/
	591
	592	/* Common SWIG API */
	593	#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
	594	#define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
	595	#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
	596
	597
	598	/* Python-specific SWIG API */
	599	#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
	600	#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
	601
	602
	603	/* -----------------------------------------------------------------------------
	604	* Pointer declarations
	605	* ----------------------------------------------------------------------------- */
	606	/*
	607	Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
	608	C/C++ pointers in the python side. Very useful for debugging, but
	609	not always safe.
	610	*/
	611	#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
	612	# define SWIG_COBJECT_TYPES
	613	#endif
	614
	615	/* Flags for pointer conversion */
	616	#define SWIG_POINTER_EXCEPTION 0x1
	617	#define SWIG_POINTER_DISOWN 0x2
	618
	619
	620	#ifdef __cplusplus
	621	extern "C" {
	622	#endif
	623
	624	/* -----------------------------------------------------------------------------
	625	* Create a new pointer string
	626	* ----------------------------------------------------------------------------- */
	627
	628	#ifndef SWIG_BUFFER_SIZE
	629	#define SWIG_BUFFER_SIZE 1024
	630	#endif
	631
	632	#if defined(SWIG_COBJECT_TYPES)
	633	#if !defined(SWIG_COBJECT_PYTHON)
	634	/* -----------------------------------------------------------------------------
	635	* Implements a simple Swig Object type, and use it instead of PyCObject
	636	* ----------------------------------------------------------------------------- */
	637
	638	typedef struct {
	639	PyObject_HEAD
	640	void *ptr;
	641	const char *desc;
	642	} PySwigObject;
	643
	644	/* Declarations for objects of type PySwigObject */
	645
	646	SWIGRUNTIME int
	647	PySwigObject_print(PySwigObject v, FILE fp, int flags)
	648	{
	649	char result[SWIG_BUFFER_SIZE];
	650	if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
	651	fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
	652	return 0;
	653	} else {
	654	return 1;
	655	}
	656	}
	657
	658	SWIGRUNTIME PyObject *
	659	PySwigObject_repr(PySwigObject *v)
	660	{
	661	char result[SWIG_BUFFER_SIZE];
	662	return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
	663	PyString_FromFormat("<Swig Object at %s>", result) : 0;
	664	}
	665
	666	SWIGRUNTIME PyObject *
	667	PySwigObject_str(PySwigObject *v)
	668	{
	669	char result[SWIG_BUFFER_SIZE];
	670	return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
	671	PyString_FromString(result) : 0;
	672	}
	673
	674	SWIGRUNTIME PyObject *
	675	PySwigObject_long(PySwigObject *v)
	676	{
	677	return PyLong_FromUnsignedLong((unsigned long) v->ptr);
	678	}
	679
	680	SWIGRUNTIME PyObject *
	681	PySwigObject_oct(PySwigObject *v)
	682	{
	683	char buf[100];
	684	unsigned long x = (unsigned long)v->ptr;
	685	if (x == 0)
	686	strcpy(buf, "0");
	687	else
	688	PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
	689	return PyString_FromString(buf);
	690	}
	691
	692	SWIGRUNTIME PyObject *
	693	PySwigObject_hex(PySwigObject *v)
	694	{
	695	char buf[100];
	696	PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
	697	return PyString_FromString(buf);
	698	}
	699
	700	SWIGRUNTIME int
	701	PySwigObject_compare(PySwigObject v, PySwigObject w)
	702	{
	703	int c = strcmp(v->desc, w->desc);
	704	if (c) {
	705	return c;
	706	} else {
	707	void *i = v->ptr;
	708	void *j = w->ptr;
	709	return (i < j) ? -1 : (i > j) ? 1 : 0;
	710	}
	711	}
	712
	713	SWIGRUNTIME void
	714	PySwigObject_dealloc(PySwigObject *self)
	715	{
	716	PyObject_DEL(self);
	717	}
	718
	719	SWIGRUNTIME PyTypeObject*
	720	PySwigObject_GetType() {
	721	static char PySwigObject_Type__doc__[] =
	722	"Swig object carries a C/C++ instance pointer";
	723
	724	static PyNumberMethods PySwigObject_as_number = {
	725	(binaryfunc)0, /nb_add/
	726	(binaryfunc)0, /nb_subtract/
	727	(binaryfunc)0, /nb_multiply/
	728	(binaryfunc)0, /nb_divide/
	729	(binaryfunc)0, /nb_remainder/
	730	(binaryfunc)0, /nb_divmod/
	731	(ternaryfunc)0,/nb_power/
	732	(unaryfunc)0, /nb_negative/
	733	(unaryfunc)0, /nb_positive/
	734	(unaryfunc)0, /nb_absolute/
	735	(inquiry)0, /nb_nonzero/
	736	0, /nb_invert/
	737	0, /nb_lshift/
	738	0, /nb_rshift/
	739	0, /nb_and/
	740	0, /nb_xor/
	741	0, /nb_or/
	742	(coercion)0, /nb_coerce/
	743	(unaryfunc)PySwigObject_long, /nb_int/
	744	(unaryfunc)PySwigObject_long, /nb_long/
	745	(unaryfunc)0, /nb_float/
	746	(unaryfunc)PySwigObject_oct, /nb_oct/
	747	(unaryfunc)PySwigObject_hex, /nb_hex/
	748	#if PY_VERSION_HEX >= 0x02000000
	749	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
	750	#endif
	751	};
	752
	753	static int type_init = 0;
	754	static PyTypeObject PySwigObject_Type;
	755
	756	if (!type_init) {
	757	PyTypeObject tmp = {
	758	PyObject_HEAD_INIT(&PyType_Type)
	759	0, /ob_size/
	760	"PySwigObject", /tp_name/
	761	sizeof(PySwigObject), /tp_basicsize/
	762	0, /tp_itemsize/
	763	/* methods */
	764	(destructor)PySwigObject_dealloc, /tp_dealloc/
	765	(printfunc)PySwigObject_print, /tp_print/
	766	(getattrfunc)0, /tp_getattr/
	767	(setattrfunc)0, /tp_setattr/
	768	(cmpfunc)PySwigObject_compare, /tp_compare/
	769	(reprfunc)PySwigObject_repr, /tp_repr/
	770	&PySwigObject_as_number, /tp_as_number/
	771	0, /tp_as_sequence/
	772	0, /tp_as_mapping/
	773	(hashfunc)0, /tp_hash/
	774	(ternaryfunc)0, /tp_call/
	775	(reprfunc)PySwigObject_str, /tp_str/
	776	/* Space for future expansion */
	777	0L,0L,0L,0L,
	778	PySwigObject_Type__doc__, /* Documentation string */
	779	#if PY_VERSION_HEX >= 0x02000000
	780	0, /* tp_traverse */
	781	0, /* tp_clear */
	782	#endif
	783	#if PY_VERSION_HEX >= 0x02010000
	784	0, /* tp_richcompare */
	785	0, /* tp_weaklistoffset */
	786	#endif
	787	#if PY_VERSION_HEX >= 0x02020000
	788	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
	789	#endif
	790	#if PY_VERSION_HEX >= 0x02030000
	791	0, /* tp_del */
	792	#endif
	793	#ifdef COUNT_ALLOCS
	794	0,0,0,0 /* tp_alloc -> tp_next */
	795	#endif
	796	};
	797
	798	PySwigObject_Type = tmp;
	799	type_init = 1;
	800	}
	801
	802	return &PySwigObject_Type;
	803	}
	804
	805	SWIGRUNTIME PyObject *
	806	PySwigObject_FromVoidPtrAndDesc(void ptr, const char desc)
	807	{
	808	PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
	809	if (self == NULL) return NULL;
	810	self->ptr = ptr;
	811	self->desc = desc;
	812	return (PyObject *)self;
	813	}
	814
	815	SWIGRUNTIMEINLINE void *
	816	PySwigObject_AsVoidPtr(PyObject *self)
	817	{
	818	return ((PySwigObject *)self)->ptr;
	819	}
	820
	821	SWIGRUNTIMEINLINE const char *
	822	PySwigObject_GetDesc(PyObject *self)
	823	{
	824	return ((PySwigObject *)self)->desc;
	825	}
	826
	827	SWIGRUNTIMEINLINE int
	828	PySwigObject_Check(PyObject *op) {
	829	return ((op)->ob_type == PySwigObject_GetType())
	830	\|\| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
	831	}
	832
	833	/* -----------------------------------------------------------------------------
	834	* Implements a simple Swig Packed type, and use it instead of string
	835	* ----------------------------------------------------------------------------- */
	836
	837	typedef struct {
	838	PyObject_HEAD
	839	void *pack;
	840	const char *desc;
	841	size_t size;
	842	} PySwigPacked;
	843
	844	SWIGRUNTIME int
	845	PySwigPacked_print(PySwigPacked v, FILE fp, int flags)
	846	{
	847	char result[SWIG_BUFFER_SIZE];
	848	fputs("<Swig Packed ", fp);
	849	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
	850	fputs("at ", fp);
	851	fputs(result, fp);
	852	}
	853	fputs(v->desc,fp);
	854	fputs(">", fp);
	855	return 0;
	856	}
	857
	858	SWIGRUNTIME PyObject *
	859	PySwigPacked_repr(PySwigPacked *v)
	860	{
	861	char result[SWIG_BUFFER_SIZE];
	862	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
	863	return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
	864	} else {
	865	return PyString_FromFormat("<Swig Packed %s>", v->desc);
	866	}
	867	}
	868
	869	SWIGRUNTIME PyObject *
	870	PySwigPacked_str(PySwigPacked *v)
	871	{
	872	char result[SWIG_BUFFER_SIZE];
	873	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
	874	return PyString_FromFormat("%s%s", result, v->desc);
	875	} else {
	876	return PyString_FromFormat("%s", v->desc);
	877	}
	878	}
	879
	880	SWIGRUNTIME int
	881	PySwigPacked_compare(PySwigPacked v, PySwigPacked w)
	882	{
	883	int c = strcmp(v->desc, w->desc);
	884	if (c) {
	885	return c;
	886	} else {
	887	size_t i = v->size;
	888	size_t j = w->size;
	889	int s = (i < j) ? -1 : (i > j) ? 1 : 0;
	890	return s ? s : strncmp((char )v->pack, (char )w->pack, 2*v->size);
	891	}
	892	}
	893
	894	SWIGRUNTIME void
	895	PySwigPacked_dealloc(PySwigPacked *self)
	896	{
	897	free(self->pack);
	898	PyObject_DEL(self);
	899	}
	900
	901	SWIGRUNTIME PyTypeObject*
	902	PySwigPacked_GetType() {
	903	static char PySwigPacked_Type__doc__[] =
	904	"Swig object carries a C/C++ instance pointer";
	905	static int type_init = 0;
	906
	907	static PyTypeObject PySwigPacked_Type;
	908	if (!type_init) {
	909	PyTypeObject tmp = {
	910	PyObject_HEAD_INIT(&PyType_Type)
	911	0, /ob_size/
	912	"PySwigPacked", /tp_name/
	913	sizeof(PySwigPacked), /tp_basicsize/
	914	0, /tp_itemsize/
	915	/* methods */
	916	(destructor)PySwigPacked_dealloc, /tp_dealloc/
	917	(printfunc)PySwigPacked_print, /tp_print/
	918	(getattrfunc)0, /tp_getattr/
	919	(setattrfunc)0, /tp_setattr/
	920	(cmpfunc)PySwigPacked_compare, /tp_compare/
	921	(reprfunc)PySwigPacked_repr, /tp_repr/
	922	0, /tp_as_number/
	923	0, /tp_as_sequence/
	924	0, /tp_as_mapping/
	925	(hashfunc)0, /tp_hash/
	926	(ternaryfunc)0, /tp_call/
	927	(reprfunc)PySwigPacked_str, /tp_str/
	928	/* Space for future expansion */
	929	0L,0L,0L,0L,
	930	PySwigPacked_Type__doc__, /* Documentation string */
	931	#if PY_VERSION_HEX >= 0x02000000
	932	0, /* tp_traverse */
	933	0, /* tp_clear */
	934	#endif
	935	#if PY_VERSION_HEX >= 0x02010000
	936	0, /* tp_richcompare */
	937	0, /* tp_weaklistoffset */
	938	#endif
	939	#if PY_VERSION_HEX >= 0x02020000
	940	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
	941	#endif
	942	#if PY_VERSION_HEX >= 0x02030000
	943	0, /* tp_del */
	944	#endif
	945	#ifdef COUNT_ALLOCS
	946	0,0,0,0 /* tp_alloc -> tp_next */
	947	#endif
	948	};
	949
	950	PySwigPacked_Type = tmp;
	951	type_init = 1;
	952	}
	953
	954
	955
	956	return &PySwigPacked_Type;
	957	}
	958
	959	SWIGRUNTIME PyObject *
	960	PySwigPacked_FromDataAndDesc(void ptr, size_t size, const char desc)
	961	{
	962	PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
	963	if (self == NULL) {
	964	return NULL;
	965	} else {
	966	void *pack = malloc(size);
	967	memcpy(pack, ptr, size);
	968	self->pack = pack;
	969	self->desc = desc;
	970	self->size = size;
	971	return (PyObject *) self;
	972	}
	973	}
	974
	975	SWIGRUNTIMEINLINE const char *
	976	PySwigPacked_UnpackData(PyObject obj, void ptr, size_t size)
	977	{
	978	PySwigPacked self = (PySwigPacked )obj;
	979	if (self->size != size) return 0;
	980	memcpy(ptr, self->pack, size);
	981	return self->desc;
	982	}
	983
	984	SWIGRUNTIMEINLINE const char *
	985	PySwigPacked_GetDesc(PyObject *self)
	986	{
	987	return ((PySwigPacked *)self)->desc;
	988	}
	989
	990	SWIGRUNTIMEINLINE int
	991	PySwigPacked_Check(PyObject *op) {
	992	return ((op)->ob_type == PySwigPacked_GetType())
	993	\|\| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
	994	}
	995
	996	#else
	997	/* -----------------------------------------------------------------------------
	998	* Use the old Python PyCObject instead of PySwigObject
	999	* ----------------------------------------------------------------------------- */
	1000
	1001	#define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
	1002	#define PySwigObject_Check(obj) PyCObject_Check(obj)
	1003	#define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
	1004	#define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
	1005
	1006	#endif
	1007
	1008	#endif
	1009
	1010	/* -----------------------------------------------------------------------------
	1011	* errors manipulation
	1012	* ----------------------------------------------------------------------------- */
	1013
	1014	SWIGRUNTIME void
	1015	SWIG_Python_TypeError(const char type, PyObject obj)
	1016	{
	1017	if (type) {
	1018	#if defined(SWIG_COBJECT_TYPES)
	1019	if (PySwigObject_Check(obj)) {
	1020	const char otype = (const char ) PySwigObject_GetDesc(obj);
	1021	if (otype) {
	1022	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
	1023	type, otype);
	1024	return;
	1025	}
	1026	} else
	1027	#endif
	1028	{
	1029	const char *otype = (obj ? obj->ob_type->tp_name : 0);
	1030	if (otype) {
	1031	PyObject *str = PyObject_Str(obj);
	1032	const char *cstr = str ? PyString_AsString(str) : 0;
	1033	if (cstr) {
	1034	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
	1035	type, otype, cstr);
	1036	} else {
	1037	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
	1038	type, otype);
	1039	}
	1040	if (str)
	1041	Py_DECREF(str);
	1042	return;
	1043	}
	1044	}
	1045	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
	1046	} else {
	1047	PyErr_Format(PyExc_TypeError, "unexpected type is received");
	1048	}
	1049	}
	1050
	1051	SWIGRUNTIMEINLINE void
	1052	SWIG_Python_NullRef(const char *type)
	1053	{
	1054	if (type) {
	1055	PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
	1056	} else {
	1057	PyErr_Format(PyExc_TypeError, "null reference was received");
	1058	}
	1059	}
	1060
	1061	SWIGRUNTIME int
	1062	SWIG_Python_AddErrMesg(const char* mesg, int infront)
	1063	{
	1064	if (PyErr_Occurred()) {
	1065	PyObject *type = 0;
	1066	PyObject *value = 0;
	1067	PyObject *traceback = 0;
	1068	PyErr_Fetch(&type, &value, &traceback);
	1069	if (value) {
	1070	PyObject *old_str = PyObject_Str(value);
	1071	Py_XINCREF(type);
	1072	PyErr_Clear();
	1073	if (infront) {
	1074	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
	1075	} else {
	1076	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
	1077	}
	1078	Py_DECREF(old_str);
	1079	}
	1080	return 1;
	1081	} else {
	1082	return 0;
	1083	}
	1084	}
	1085
	1086	SWIGRUNTIME int
	1087	SWIG_Python_ArgFail(int argnum)
	1088	{
	1089	if (PyErr_Occurred()) {
	1090	/* add information about failing argument */
	1091	char mesg[256];
	1092	sprintf(mesg, "argument number %d:", argnum);
	1093	return SWIG_Python_AddErrMesg(mesg, 1);
	1094	} else {
	1095	return 0;
	1096	}
	1097	}
	1098
	1099
	1100	/* -----------------------------------------------------------------------------
	1101	* pointers/data manipulation
	1102	* ----------------------------------------------------------------------------- */
	1103
	1104	/* Convert a pointer value */
	1105	SWIGRUNTIME int
	1106	SWIG_Python_ConvertPtr(PyObject obj, void ptr, swig_type_info ty, int flags) {
	1107	swig_type_info *tc;
	1108	const char *c = 0;
	1109	static PyObject *SWIG_this = 0;
	1110	int newref = 0;
	1111	PyObject *pyobj = 0;
	1112	void *vptr;
	1113
	1114	if (!obj) return 0;
	1115	if (obj == Py_None) {
	1116	*ptr = 0;
	1117	return 0;
	1118	}
	1119
	1120	#ifdef SWIG_COBJECT_TYPES
	1121	if (!(PySwigObject_Check(obj))) {
	1122	if (!SWIG_this)
	1123	SWIG_this = PyString_FromString("this");
	1124	pyobj = obj;
	1125	obj = PyObject_GetAttr(obj,SWIG_this);
	1126	newref = 1;
	1127	if (!obj) goto type_error;
	1128	if (!PySwigObject_Check(obj)) {
	1129	Py_DECREF(obj);
	1130	goto type_error;
	1131	}
	1132	}
	1133	vptr = PySwigObject_AsVoidPtr(obj);
	1134	c = (const char *) PySwigObject_GetDesc(obj);
	1135	if (newref) { Py_DECREF(obj); }
	1136	goto type_check;
	1137	#else
	1138	if (!(PyString_Check(obj))) {
	1139	if (!SWIG_this)
	1140	SWIG_this = PyString_FromString("this");
	1141	pyobj = obj;
	1142	obj = PyObject_GetAttr(obj,SWIG_this);
	1143	newref = 1;
	1144	if (!obj) goto type_error;
	1145	if (!PyString_Check(obj)) {
	1146	Py_DECREF(obj);
	1147	goto type_error;
	1148	}
	1149	}
	1150	c = PyString_AS_STRING(obj);
	1151	/* Pointer values must start with leading underscore */
	1152	c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
	1153	if (newref) { Py_DECREF(obj); }
	1154	if (!c) goto type_error;
	1155	#endif
	1156
	1157	type_check:
	1158
	1159	if (ty) {
	1160	tc = SWIG_TypeCheck(c,ty);
	1161	if (!tc) goto type_error;
	1162	*ptr = SWIG_TypeCast(tc,vptr);
	1163	} else {
	1164	*ptr = vptr;
	1165	}
	1166
	1167	if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
	1168	PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
	1169	}
	1170	return 0;
	1171
	1172	type_error:
	1173	PyErr_Clear();
	1174	if (pyobj && !obj) {
	1175	obj = pyobj;
	1176	if (PyCFunction_Check(obj)) {
	1177	/* here we get the method pointer for callbacks */
	1178	char doc = (((PyCFunctionObject )obj) -> m_ml -> ml_doc);
	1179	c = doc ? strstr(doc, "swig_ptr: ") : 0;
	1180	if (c) {
	1181	c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
	1182	if (!c) goto type_error;
	1183	goto type_check;
	1184	}
	1185	}
	1186	}
	1187	if (flags & SWIG_POINTER_EXCEPTION) {
	1188	if (ty) {
	1189	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
	1190	} else {
	1191	SWIG_Python_TypeError("C/C++ pointer", obj);
	1192	}
	1193	}
	1194	return -1;
	1195	}
	1196
	1197	/* Convert a pointer value, signal an exception on a type mismatch */
	1198	SWIGRUNTIME void *
	1199	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int argnum, int flags) {
	1200	void *result;
	1201	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
	1202	PyErr_Clear();
	1203	if (flags & SWIG_POINTER_EXCEPTION) {
	1204	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
	1205	SWIG_Python_ArgFail(argnum);
	1206	}
	1207	}
	1208	return result;
	1209	}
	1210
	1211	/* Convert a packed value value */
	1212	SWIGRUNTIME int
	1213	SWIG_Python_ConvertPacked(PyObject obj, void ptr, size_t sz, swig_type_info *ty, int flags) {
	1214	swig_type_info *tc;
	1215	const char *c = 0;
	1216
	1217	#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
	1218	c = PySwigPacked_UnpackData(obj, ptr, sz);
	1219	#else
	1220	if ((!obj) \|\| (!PyString_Check(obj))) goto type_error;
	1221	c = PyString_AS_STRING(obj);
	1222	/* Pointer values must start with leading underscore */
	1223	c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
	1224	#endif
	1225	if (!c) goto type_error;
	1226	if (ty) {
	1227	tc = SWIG_TypeCheck(c,ty);
	1228	if (!tc) goto type_error;
	1229	}
	1230	return 0;
	1231
	1232	type_error:
	1233	PyErr_Clear();
	1234	if (flags & SWIG_POINTER_EXCEPTION) {
	1235	if (ty) {
	1236	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
	1237	} else {
	1238	SWIG_Python_TypeError("C/C++ packed data", obj);
	1239	}
	1240	}
	1241	return -1;
	1242	}
	1243
	1244	/* Create a new array object */
	1245	SWIGRUNTIME PyObject *
	1246	SWIG_Python_NewPointerObj(void ptr, swig_type_info type, int own) {
	1247	PyObject *robj = 0;
	1248	if (!ptr) {
	1249	Py_INCREF(Py_None);
	1250	return Py_None;
	1251	}
	1252	#ifdef SWIG_COBJECT_TYPES
	1253	robj = PySwigObject_FromVoidPtrAndDesc((void ) ptr, (char )type->name);
	1254	#else
	1255	{
	1256	char result[SWIG_BUFFER_SIZE];
	1257	robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
	1258	PyString_FromString(result) : 0;
	1259	}
	1260	#endif
	1261	if (!robj \|\| (robj == Py_None)) return robj;
	1262	if (type->clientdata) {
	1263	PyObject *inst;
	1264	PyObject args = Py_BuildValue((char)"(O)", robj);
	1265	Py_DECREF(robj);
	1266	inst = PyObject_CallObject((PyObject *) type->clientdata, args);
	1267	Py_DECREF(args);
	1268	if (inst) {
	1269	if (own) {
	1270	PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
	1271	}
	1272	robj = inst;
	1273	}
	1274	}
	1275	return robj;
	1276	}
	1277
	1278	SWIGRUNTIME PyObject *
	1279	SWIG_Python_NewPackedObj(void ptr, size_t sz, swig_type_info type) {
	1280	PyObject *robj = 0;
	1281	if (!ptr) {
	1282	Py_INCREF(Py_None);
	1283	return Py_None;
	1284	}
	1285	#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
	1286	robj = PySwigPacked_FromDataAndDesc((void ) ptr, sz, (char )type->name);
	1287	#else
	1288	{
	1289	char result[SWIG_BUFFER_SIZE];
	1290	robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
	1291	PyString_FromString(result) : 0;
	1292	}
	1293	#endif
	1294	return robj;
	1295	}
	1296
	1297	/* -----------------------------------------------------------------------------*
	1298	* Get type list
	1299	* -----------------------------------------------------------------------------*/
	1300
	1301	#ifdef SWIG_LINK_RUNTIME
	1302	void SWIG_ReturnGlobalTypeList(void );
	1303	#endif
	1304
	1305	SWIGRUNTIME swig_type_info **
	1306	SWIG_Python_GetTypeListHandle() {
	1307	static void type_pointer = (void )0;
	1308	/* first check if module already created */
	1309	if (!type_pointer) {
	1310	#ifdef SWIG_LINK_RUNTIME
	1311	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
	1312	#else
	1313	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
	1314	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
	1315	if (PyErr_Occurred()) {
	1316	PyErr_Clear();
	1317	type_pointer = (void *)0;
	1318	}
	1319	}
	1320	#endif
	1321	return (swig_type_info **) type_pointer;
	1322	}
	1323
	1324	/*
	1325	Search for a swig_type_info structure
	1326	*/
	1327	SWIGRUNTIMEINLINE swig_type_info *
	1328	SWIG_Python_GetTypeList() {
	1329	swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
	1330	return tlh ? tlh : (swig_type_info)0;
	1331	}
	1332
	1333	#define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
	1334
	1335	#ifdef __cplusplus
	1336	}
	1337	#endif
	1338
	1339
	1340	/* -------- TYPES TABLE (BEGIN) -------- */
	1341
	1342	#define SWIGTYPE_p_wxRect swig_types[0]
	1343	#define SWIGTYPE_p_wxGIFAnimationCtrl swig_types[1]
	1344	#define SWIGTYPE_p_wxObject swig_types[2]
	1345	#define SWIGTYPE_p_unsigned_char swig_types[3]
	1346	#define SWIGTYPE_p_wxColour swig_types[4]
	1347	#define SWIGTYPE_p_wxAnimationPlayer swig_types[5]
	1348	#define SWIGTYPE_p_wxWindow swig_types[6]
	1349	#define SWIGTYPE_p_unsigned_long swig_types[7]
	1350	#define SWIGTYPE_p_wxBitmap swig_types[8]
	1351	#define SWIGTYPE_p_form_ops_t swig_types[9]
	1352	#define SWIGTYPE_p_unsigned_int swig_types[10]
	1353	#define SWIGTYPE_unsigned_int swig_types[11]
	1354	#define SWIGTYPE_p_wxDuplexMode swig_types[12]
	1355	#define SWIGTYPE_p_wxGIFAnimation swig_types[13]
	1356	#define SWIGTYPE_p_char swig_types[14]
	1357	#define SWIGTYPE_p_wxAnimationBase swig_types[15]
	1358	#define SWIGTYPE_p_wxPoint swig_types[16]
	1359	#define SWIGTYPE_p_wxDC swig_types[17]
	1360	#define SWIGTYPE_p_wxEvtHandler swig_types[18]
	1361	#define SWIGTYPE_std__ptrdiff_t swig_types[19]
	1362	#define SWIGTYPE_ptrdiff_t swig_types[20]
	1363	#define SWIGTYPE_p_wxControl swig_types[21]
	1364	#define SWIGTYPE_p_wxPaperSize swig_types[22]
	1365	#define SWIGTYPE_p_wxSize swig_types[23]
	1366	#define SWIGTYPE_p_int swig_types[24]
	1367	static swig_type_info *swig_types[26];
	1368
	1369	/* -------- TYPES TABLE (END) -------- */
	1370
	1371
	1372	/*-----------------------------------------------
	1373	@(target):= _animate.so
	1374	------------------------------------------------*/
	1375	#define SWIG_init init_animate
	1376
	1377	#define SWIG_name "_animate"
	1378
	1379	#include "wx/wxPython/wxPython.h"
	1380	#include "wx/wxPython/pyclasses.h"
	1381	#include <wx/animate/animate.h>
	1382
	1383	static const wxString wxPyAnimationControlNameStr(wxT("animationControl"));
	1384	static const wxString wxPyEmptyString(wxEmptyString);
	1385
	1386	/@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@/
	1387	#define SWIG_From_int PyInt_FromLong
	1388	/@@/
	1389
	1390
	1391	#include <limits.h>
	1392
	1393
	1394	SWIGINTERN int
	1395	SWIG_CheckLongInRange(long value, long min_value, long max_value,
	1396	const char *errmsg)
	1397	{
	1398	if (value < min_value) {
	1399	if (errmsg) {
	1400	PyErr_Format(PyExc_OverflowError,
	1401	"value %ld is less than '%s' minimum %ld",
	1402	value, errmsg, min_value);
	1403	}
	1404	return 0;
	1405	} else if (value > max_value) {
	1406	if (errmsg) {
	1407	PyErr_Format(PyExc_OverflowError,
	1408	"value %ld is greater than '%s' maximum %ld",
	1409	value, errmsg, max_value);
	1410	}
	1411	return 0;
	1412	}
	1413	return 1;
	1414	}
	1415
	1416
	1417	SWIGINTERN int
	1418	SWIG_AsVal_long(PyObject* obj, long* val)
	1419	{
	1420	if (PyNumber_Check(obj)) {
	1421	if (val) *val = PyInt_AsLong(obj);
	1422	return 1;
	1423	}
	1424	else {
	1425	SWIG_type_error("number", obj);
	1426	}
	1427	return 0;
	1428	}
	1429
	1430
	1431	#if INT_MAX != LONG_MAX
	1432	SWIGINTERN int
	1433	SWIG_AsVal_int(PyObject obj, int val)
	1434	{
	1435	const char* errmsg = val ? "int" : (char*)0;
	1436	long v;
	1437	if (SWIG_AsVal_long(obj, &v)) {
	1438	if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
	1439	if (val) *val = (int)(v);
	1440	return 1;
	1441	} else {
	1442	return 0;
	1443	}
	1444	} else {
	1445	PyErr_Clear();
	1446	}
	1447	if (val) {
	1448	SWIG_type_error(errmsg, obj);
	1449	}
	1450	return 0;
	1451	}
	1452	#else
	1453	SWIGINTERNSHORT int
	1454	SWIG_AsVal_int(PyObject obj, int val)
	1455	{
	1456	return SWIG_AsVal_long(obj,(long*)val);
	1457	}
	1458	#endif
	1459
	1460
	1461	SWIGINTERN int
	1462	SWIG_AsVal_bool(PyObject obj, bool val)
	1463	{
	1464	if (obj == Py_True) {
	1465	if (val) *val = true;
	1466	return 1;
	1467	}
	1468	if (obj == Py_False) {
	1469	if (val) *val = false;
	1470	return 1;
	1471	}
	1472	int res = 0;
	1473	if (SWIG_AsVal_int(obj, &res)) {
	1474	if (val) *val = res ? true : false;
	1475	return 1;
	1476	} else {
	1477	PyErr_Clear();
	1478	}
	1479	if (val) {
	1480	SWIG_type_error("bool", obj);
	1481	}
	1482	return 0;
	1483	}
	1484
	1485
	1486	SWIGINTERNSHORT bool
	1487	SWIG_As_bool(PyObject* obj)
	1488	{
	1489	bool v;
	1490	if (!SWIG_AsVal_bool(obj, &v)) {
	1491	/*
	1492	this is needed to make valgrind/purify happier.
	1493	*/
	1494	memset((void*)&v, 0, sizeof(bool));
	1495	}
	1496	return v;
	1497	}
	1498
	1499
	1500	SWIGINTERNSHORT int
	1501	SWIG_Check_bool(PyObject* obj)
	1502	{
	1503	return SWIG_AsVal_bool(obj, (bool*)0);
	1504	}
	1505
	1506
	1507	SWIGINTERNSHORT int
	1508	SWIG_As_int(PyObject* obj)
	1509	{
	1510	int v;
	1511	if (!SWIG_AsVal_int(obj, &v)) {
	1512	/*
	1513	this is needed to make valgrind/purify happier.
	1514	*/
	1515	memset((void*)&v, 0, sizeof(int));
	1516	}
	1517	return v;
	1518	}
	1519
	1520
	1521	SWIGINTERNSHORT int
	1522	SWIG_Check_int(PyObject* obj)
	1523	{
	1524	return SWIG_AsVal_int(obj, (int*)0);
	1525	}
	1526
	1527
	1528	SWIGINTERNSHORT long
	1529	SWIG_As_long(PyObject* obj)
	1530	{
	1531	long v;
	1532	if (!SWIG_AsVal_long(obj, &v)) {
	1533	/*
	1534	this is needed to make valgrind/purify happier.
	1535	*/
	1536	memset((void*)&v, 0, sizeof(long));
	1537	}
	1538	return v;
	1539	}
	1540
	1541
	1542	SWIGINTERNSHORT int
	1543	SWIG_Check_long(PyObject* obj)
	1544	{
	1545	return SWIG_AsVal_long(obj, (long*)0);
	1546	}
	1547
	1548	#ifdef __cplusplus
	1549	extern "C" {
	1550	#endif
	1551	static int _wrap_AnimationControlNameStr_set(PyObject *) {
	1552	PyErr_SetString(PyExc_TypeError,"Variable AnimationControlNameStr is read-only.");
	1553	return 1;
	1554	}
	1555
	1556
	1557	static PyObject *_wrap_AnimationControlNameStr_get(void) {
	1558	PyObject *pyobj;
	1559
	1560	{
	1561	#if wxUSE_UNICODE
	1562	pyobj = PyUnicode_FromWideChar((&wxPyAnimationControlNameStr)->c_str(), (&wxPyAnimationControlNameStr)->Len());
	1563	#else
	1564	pyobj = PyString_FromStringAndSize((&wxPyAnimationControlNameStr)->c_str(), (&wxPyAnimationControlNameStr)->Len());
	1565	#endif
	1566	}
	1567	return pyobj;
	1568	}
	1569
	1570
	1571	static PyObject _wrap_new_AnimationPlayer(PyObject , PyObject args, PyObject kwargs) {
	1572	PyObject *resultobj;
	1573	wxAnimationBase arg1 = (wxAnimationBase ) NULL ;
	1574	bool arg2 = (bool) false ;
	1575	wxAnimationPlayer *result;
	1576	PyObject * obj0 = 0 ;
	1577	PyObject * obj1 = 0 ;
	1578	char *kwnames[] = {
	1579	(char ) "animation",(char ) "destroyAnimation", NULL
	1580	};
	1581
	1582	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"\|OO:new_AnimationPlayer",kwnames,&obj0,&obj1)) goto fail;
	1583	if (obj0) {
	1584	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	1585	if (SWIG_arg_fail(1)) SWIG_fail;
	1586	}
	1587	if (obj1) {
	1588	{
	1589	arg2 = (bool)(SWIG_As_bool(obj1));
	1590	if (SWIG_arg_fail(2)) SWIG_fail;
	1591	}
	1592	}
	1593	{
	1594	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1595	result = (wxAnimationPlayer *)new wxAnimationPlayer(arg1,arg2);
	1596
	1597	wxPyEndAllowThreads(__tstate);
	1598	if (PyErr_Occurred()) SWIG_fail;
	1599	}
	1600	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAnimationPlayer, 1);
	1601	return resultobj;
	1602	fail:
	1603	return NULL;
	1604	}
	1605
	1606
	1607	static PyObject _wrap_delete_AnimationPlayer(PyObject , PyObject args, PyObject kwargs) {
	1608	PyObject *resultobj;
	1609	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1610	PyObject * obj0 = 0 ;
	1611	char *kwnames[] = {
	1612	(char *) "self", NULL
	1613	};
	1614
	1615	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AnimationPlayer",kwnames,&obj0)) goto fail;
	1616	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1617	if (SWIG_arg_fail(1)) SWIG_fail;
	1618	{
	1619	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1620	delete arg1;
	1621
	1622	wxPyEndAllowThreads(__tstate);
	1623	if (PyErr_Occurred()) SWIG_fail;
	1624	}
	1625	Py_INCREF(Py_None); resultobj = Py_None;
	1626	return resultobj;
	1627	fail:
	1628	return NULL;
	1629	}
	1630
	1631
	1632	static PyObject _wrap_AnimationPlayer_SetAnimation(PyObject , PyObject args, PyObject kwargs) {
	1633	PyObject *resultobj;
	1634	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1635	wxAnimationBase arg2 = (wxAnimationBase ) 0 ;
	1636	bool arg3 = (bool) false ;
	1637	PyObject * obj0 = 0 ;
	1638	PyObject * obj1 = 0 ;
	1639	PyObject * obj2 = 0 ;
	1640	char *kwnames[] = {
	1641	(char ) "self",(char ) "animation",(char *) "destroyAnimation", NULL
	1642	};
	1643
	1644	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO\|O:AnimationPlayer_SetAnimation",kwnames,&obj0,&obj1,&obj2)) goto fail;
	1645	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1646	if (SWIG_arg_fail(1)) SWIG_fail;
	1647	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	1648	if (SWIG_arg_fail(2)) SWIG_fail;
	1649	if (obj2) {
	1650	{
	1651	arg3 = (bool)(SWIG_As_bool(obj2));
	1652	if (SWIG_arg_fail(3)) SWIG_fail;
	1653	}
	1654	}
	1655	{
	1656	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1657	(arg1)->SetAnimation(arg2,arg3);
	1658
	1659	wxPyEndAllowThreads(__tstate);
	1660	if (PyErr_Occurred()) SWIG_fail;
	1661	}
	1662	Py_INCREF(Py_None); resultobj = Py_None;
	1663	return resultobj;
	1664	fail:
	1665	return NULL;
	1666	}
	1667
	1668
	1669	static PyObject _wrap_AnimationPlayer_GetAnimation(PyObject , PyObject args, PyObject kwargs) {
	1670	PyObject *resultobj;
	1671	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1672	wxAnimationBase *result;
	1673	PyObject * obj0 = 0 ;
	1674	char *kwnames[] = {
	1675	(char *) "self", NULL
	1676	};
	1677
	1678	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetAnimation",kwnames,&obj0)) goto fail;
	1679	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1680	if (SWIG_arg_fail(1)) SWIG_fail;
	1681	{
	1682	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1683	result = (wxAnimationBase )((wxAnimationPlayer const )arg1)->GetAnimation();
	1684
	1685	wxPyEndAllowThreads(__tstate);
	1686	if (PyErr_Occurred()) SWIG_fail;
	1687	}
	1688	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAnimationBase, 0);
	1689	return resultobj;
	1690	fail:
	1691	return NULL;
	1692	}
	1693
	1694
	1695	static PyObject _wrap_AnimationPlayer_SetDestroyAnimation(PyObject , PyObject args, PyObject kwargs) {
	1696	PyObject *resultobj;
	1697	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1698	bool arg2 ;
	1699	PyObject * obj0 = 0 ;
	1700	PyObject * obj1 = 0 ;
	1701	char *kwnames[] = {
	1702	(char ) "self",(char ) "destroyAnimation", NULL
	1703	};
	1704
	1705	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_SetDestroyAnimation",kwnames,&obj0,&obj1)) goto fail;
	1706	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1707	if (SWIG_arg_fail(1)) SWIG_fail;
	1708	{
	1709	arg2 = (bool)(SWIG_As_bool(obj1));
	1710	if (SWIG_arg_fail(2)) SWIG_fail;
	1711	}
	1712	{
	1713	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1714	(arg1)->SetDestroyAnimation(arg2);
	1715
	1716	wxPyEndAllowThreads(__tstate);
	1717	if (PyErr_Occurred()) SWIG_fail;
	1718	}
	1719	Py_INCREF(Py_None); resultobj = Py_None;
	1720	return resultobj;
	1721	fail:
	1722	return NULL;
	1723	}
	1724
	1725
	1726	static PyObject _wrap_AnimationPlayer_GetDestroyAnimation(PyObject , PyObject args, PyObject kwargs) {
	1727	PyObject *resultobj;
	1728	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1729	bool result;
	1730	PyObject * obj0 = 0 ;
	1731	char *kwnames[] = {
	1732	(char *) "self", NULL
	1733	};
	1734
	1735	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetDestroyAnimation",kwnames,&obj0)) goto fail;
	1736	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1737	if (SWIG_arg_fail(1)) SWIG_fail;
	1738	{
	1739	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1740	result = (bool)((wxAnimationPlayer const *)arg1)->GetDestroyAnimation();
	1741
	1742	wxPyEndAllowThreads(__tstate);
	1743	if (PyErr_Occurred()) SWIG_fail;
	1744	}
	1745	{
	1746	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	1747	}
	1748	return resultobj;
	1749	fail:
	1750	return NULL;
	1751	}
	1752
	1753
	1754	static PyObject _wrap_AnimationPlayer_SetCurrentFrame(PyObject , PyObject args, PyObject kwargs) {
	1755	PyObject *resultobj;
	1756	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1757	int arg2 ;
	1758	PyObject * obj0 = 0 ;
	1759	PyObject * obj1 = 0 ;
	1760	char *kwnames[] = {
	1761	(char ) "self",(char ) "currentFrame", NULL
	1762	};
	1763
	1764	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_SetCurrentFrame",kwnames,&obj0,&obj1)) goto fail;
	1765	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1766	if (SWIG_arg_fail(1)) SWIG_fail;
	1767	{
	1768	arg2 = (int)(SWIG_As_int(obj1));
	1769	if (SWIG_arg_fail(2)) SWIG_fail;
	1770	}
	1771	{
	1772	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1773	(arg1)->SetCurrentFrame(arg2);
	1774
	1775	wxPyEndAllowThreads(__tstate);
	1776	if (PyErr_Occurred()) SWIG_fail;
	1777	}
	1778	Py_INCREF(Py_None); resultobj = Py_None;
	1779	return resultobj;
	1780	fail:
	1781	return NULL;
	1782	}
	1783
	1784
	1785	static PyObject _wrap_AnimationPlayer_GetCurrentFrame(PyObject , PyObject args, PyObject kwargs) {
	1786	PyObject *resultobj;
	1787	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1788	int result;
	1789	PyObject * obj0 = 0 ;
	1790	char *kwnames[] = {
	1791	(char *) "self", NULL
	1792	};
	1793
	1794	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetCurrentFrame",kwnames,&obj0)) goto fail;
	1795	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1796	if (SWIG_arg_fail(1)) SWIG_fail;
	1797	{
	1798	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1799	result = (int)((wxAnimationPlayer const *)arg1)->GetCurrentFrame();
	1800
	1801	wxPyEndAllowThreads(__tstate);
	1802	if (PyErr_Occurred()) SWIG_fail;
	1803	}
	1804	{
	1805	resultobj = SWIG_From_int((int)(result));
	1806	}
	1807	return resultobj;
	1808	fail:
	1809	return NULL;
	1810	}
	1811
	1812
	1813	static PyObject _wrap_AnimationPlayer_SetWindow(PyObject , PyObject args, PyObject kwargs) {
	1814	PyObject *resultobj;
	1815	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1816	wxWindow arg2 = (wxWindow ) 0 ;
	1817	PyObject * obj0 = 0 ;
	1818	PyObject * obj1 = 0 ;
	1819	char *kwnames[] = {
	1820	(char ) "self",(char ) "window", NULL
	1821	};
	1822
	1823	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_SetWindow",kwnames,&obj0,&obj1)) goto fail;
	1824	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1825	if (SWIG_arg_fail(1)) SWIG_fail;
	1826	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	1827	if (SWIG_arg_fail(2)) SWIG_fail;
	1828	{
	1829	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1830	(arg1)->SetWindow(arg2);
	1831
	1832	wxPyEndAllowThreads(__tstate);
	1833	if (PyErr_Occurred()) SWIG_fail;
	1834	}
	1835	Py_INCREF(Py_None); resultobj = Py_None;
	1836	return resultobj;
	1837	fail:
	1838	return NULL;
	1839	}
	1840
	1841
	1842	static PyObject _wrap_AnimationPlayer_GetWindow(PyObject , PyObject args, PyObject kwargs) {
	1843	PyObject *resultobj;
	1844	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1845	wxWindow *result;
	1846	PyObject * obj0 = 0 ;
	1847	char *kwnames[] = {
	1848	(char *) "self", NULL
	1849	};
	1850
	1851	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetWindow",kwnames,&obj0)) goto fail;
	1852	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1853	if (SWIG_arg_fail(1)) SWIG_fail;
	1854	{
	1855	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1856	result = (wxWindow )((wxAnimationPlayer const )arg1)->GetWindow();
	1857
	1858	wxPyEndAllowThreads(__tstate);
	1859	if (PyErr_Occurred()) SWIG_fail;
	1860	}
	1861	{
	1862	resultobj = wxPyMake_wxObject(result, 0);
	1863	}
	1864	return resultobj;
	1865	fail:
	1866	return NULL;
	1867	}
	1868
	1869
	1870	static PyObject _wrap_AnimationPlayer_SetPosition(PyObject , PyObject args, PyObject kwargs) {
	1871	PyObject *resultobj;
	1872	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1873	wxPoint *arg2 = 0 ;
	1874	wxPoint temp2 ;
	1875	PyObject * obj0 = 0 ;
	1876	PyObject * obj1 = 0 ;
	1877	char *kwnames[] = {
	1878	(char ) "self",(char ) "pos", NULL
	1879	};
	1880
	1881	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_SetPosition",kwnames,&obj0,&obj1)) goto fail;
	1882	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1883	if (SWIG_arg_fail(1)) SWIG_fail;
	1884	{
	1885	arg2 = &temp2;
	1886	if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
	1887	}
	1888	{
	1889	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1890	(arg1)->SetPosition((wxPoint const &)*arg2);
	1891
	1892	wxPyEndAllowThreads(__tstate);
	1893	if (PyErr_Occurred()) SWIG_fail;
	1894	}
	1895	Py_INCREF(Py_None); resultobj = Py_None;
	1896	return resultobj;
	1897	fail:
	1898	return NULL;
	1899	}
	1900
	1901
	1902	static PyObject _wrap_AnimationPlayer_GetPosition(PyObject , PyObject args, PyObject kwargs) {
	1903	PyObject *resultobj;
	1904	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1905	wxPoint result;
	1906	PyObject * obj0 = 0 ;
	1907	char *kwnames[] = {
	1908	(char *) "self", NULL
	1909	};
	1910
	1911	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetPosition",kwnames,&obj0)) goto fail;
	1912	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1913	if (SWIG_arg_fail(1)) SWIG_fail;
	1914	{
	1915	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1916	result = ((wxAnimationPlayer const *)arg1)->GetPosition();
	1917
	1918	wxPyEndAllowThreads(__tstate);
	1919	if (PyErr_Occurred()) SWIG_fail;
	1920	}
	1921	{
	1922	wxPoint * resultptr;
	1923	resultptr = new wxPoint((wxPoint &)(result));
	1924	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
	1925	}
	1926	return resultobj;
	1927	fail:
	1928	return NULL;
	1929	}
	1930
	1931
	1932	static PyObject _wrap_AnimationPlayer_SetLooped(PyObject , PyObject args, PyObject kwargs) {
	1933	PyObject *resultobj;
	1934	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1935	bool arg2 ;
	1936	PyObject * obj0 = 0 ;
	1937	PyObject * obj1 = 0 ;
	1938	char *kwnames[] = {
	1939	(char ) "self",(char ) "looped", NULL
	1940	};
	1941
	1942	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_SetLooped",kwnames,&obj0,&obj1)) goto fail;
	1943	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1944	if (SWIG_arg_fail(1)) SWIG_fail;
	1945	{
	1946	arg2 = (bool)(SWIG_As_bool(obj1));
	1947	if (SWIG_arg_fail(2)) SWIG_fail;
	1948	}
	1949	{
	1950	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1951	(arg1)->SetLooped(arg2);
	1952
	1953	wxPyEndAllowThreads(__tstate);
	1954	if (PyErr_Occurred()) SWIG_fail;
	1955	}
	1956	Py_INCREF(Py_None); resultobj = Py_None;
	1957	return resultobj;
	1958	fail:
	1959	return NULL;
	1960	}
	1961
	1962
	1963	static PyObject _wrap_AnimationPlayer_GetLooped(PyObject , PyObject args, PyObject kwargs) {
	1964	PyObject *resultobj;
	1965	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1966	bool result;
	1967	PyObject * obj0 = 0 ;
	1968	char *kwnames[] = {
	1969	(char *) "self", NULL
	1970	};
	1971
	1972	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetLooped",kwnames,&obj0)) goto fail;
	1973	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	1974	if (SWIG_arg_fail(1)) SWIG_fail;
	1975	{
	1976	PyThreadState* __tstate = wxPyBeginAllowThreads();
	1977	result = (bool)((wxAnimationPlayer const *)arg1)->GetLooped();
	1978
	1979	wxPyEndAllowThreads(__tstate);
	1980	if (PyErr_Occurred()) SWIG_fail;
	1981	}
	1982	{
	1983	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	1984	}
	1985	return resultobj;
	1986	fail:
	1987	return NULL;
	1988	}
	1989
	1990
	1991	static PyObject _wrap_AnimationPlayer_HasAnimation(PyObject , PyObject args, PyObject kwargs) {
	1992	PyObject *resultobj;
	1993	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	1994	bool result;
	1995	PyObject * obj0 = 0 ;
	1996	char *kwnames[] = {
	1997	(char *) "self", NULL
	1998	};
	1999
	2000	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_HasAnimation",kwnames,&obj0)) goto fail;
	2001	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2002	if (SWIG_arg_fail(1)) SWIG_fail;
	2003	{
	2004	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2005	result = (bool)((wxAnimationPlayer const *)arg1)->HasAnimation();
	2006
	2007	wxPyEndAllowThreads(__tstate);
	2008	if (PyErr_Occurred()) SWIG_fail;
	2009	}
	2010	{
	2011	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2012	}
	2013	return resultobj;
	2014	fail:
	2015	return NULL;
	2016	}
	2017
	2018
	2019	static PyObject _wrap_AnimationPlayer_IsPlaying(PyObject , PyObject args, PyObject kwargs) {
	2020	PyObject *resultobj;
	2021	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2022	bool result;
	2023	PyObject * obj0 = 0 ;
	2024	char *kwnames[] = {
	2025	(char *) "self", NULL
	2026	};
	2027
	2028	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_IsPlaying",kwnames,&obj0)) goto fail;
	2029	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2030	if (SWIG_arg_fail(1)) SWIG_fail;
	2031	{
	2032	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2033	result = (bool)((wxAnimationPlayer const *)arg1)->IsPlaying();
	2034
	2035	wxPyEndAllowThreads(__tstate);
	2036	if (PyErr_Occurred()) SWIG_fail;
	2037	}
	2038	{
	2039	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2040	}
	2041	return resultobj;
	2042	fail:
	2043	return NULL;
	2044	}
	2045
	2046
	2047	static PyObject _wrap_AnimationPlayer_UseBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	2048	PyObject *resultobj;
	2049	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2050	bool arg2 ;
	2051	PyObject * obj0 = 0 ;
	2052	PyObject * obj1 = 0 ;
	2053	char *kwnames[] = {
	2054	(char ) "self",(char ) "useBackground", NULL
	2055	};
	2056
	2057	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_UseBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
	2058	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2059	if (SWIG_arg_fail(1)) SWIG_fail;
	2060	{
	2061	arg2 = (bool)(SWIG_As_bool(obj1));
	2062	if (SWIG_arg_fail(2)) SWIG_fail;
	2063	}
	2064	{
	2065	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2066	(arg1)->UseBackgroundColour(arg2);
	2067
	2068	wxPyEndAllowThreads(__tstate);
	2069	if (PyErr_Occurred()) SWIG_fail;
	2070	}
	2071	Py_INCREF(Py_None); resultobj = Py_None;
	2072	return resultobj;
	2073	fail:
	2074	return NULL;
	2075	}
	2076
	2077
	2078	static PyObject _wrap_AnimationPlayer_UsingBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	2079	PyObject *resultobj;
	2080	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2081	bool result;
	2082	PyObject * obj0 = 0 ;
	2083	char *kwnames[] = {
	2084	(char *) "self", NULL
	2085	};
	2086
	2087	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_UsingBackgroundColour",kwnames,&obj0)) goto fail;
	2088	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2089	if (SWIG_arg_fail(1)) SWIG_fail;
	2090	{
	2091	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2092	result = (bool)((wxAnimationPlayer const *)arg1)->UsingBackgroundColour();
	2093
	2094	wxPyEndAllowThreads(__tstate);
	2095	if (PyErr_Occurred()) SWIG_fail;
	2096	}
	2097	{
	2098	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2099	}
	2100	return resultobj;
	2101	fail:
	2102	return NULL;
	2103	}
	2104
	2105
	2106	static PyObject _wrap_AnimationPlayer_SetCustomBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	2107	PyObject *resultobj;
	2108	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2109	wxColour *arg2 = 0 ;
	2110	bool arg3 = (bool) true ;
	2111	wxColour temp2 ;
	2112	PyObject * obj0 = 0 ;
	2113	PyObject * obj1 = 0 ;
	2114	PyObject * obj2 = 0 ;
	2115	char *kwnames[] = {
	2116	(char ) "self",(char ) "col",(char *) "useCustomBackgroundColour", NULL
	2117	};
	2118
	2119	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO\|O:AnimationPlayer_SetCustomBackgroundColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
	2120	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2121	if (SWIG_arg_fail(1)) SWIG_fail;
	2122	{
	2123	arg2 = &temp2;
	2124	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	2125	}
	2126	if (obj2) {
	2127	{
	2128	arg3 = (bool)(SWIG_As_bool(obj2));
	2129	if (SWIG_arg_fail(3)) SWIG_fail;
	2130	}
	2131	}
	2132	{
	2133	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2134	(arg1)->SetCustomBackgroundColour((wxColour const &)*arg2,arg3);
	2135
	2136	wxPyEndAllowThreads(__tstate);
	2137	if (PyErr_Occurred()) SWIG_fail;
	2138	}
	2139	Py_INCREF(Py_None); resultobj = Py_None;
	2140	return resultobj;
	2141	fail:
	2142	return NULL;
	2143	}
	2144
	2145
	2146	static PyObject _wrap_AnimationPlayer_UsingCustomBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	2147	PyObject *resultobj;
	2148	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2149	bool result;
	2150	PyObject * obj0 = 0 ;
	2151	char *kwnames[] = {
	2152	(char *) "self", NULL
	2153	};
	2154
	2155	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_UsingCustomBackgroundColour",kwnames,&obj0)) goto fail;
	2156	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2157	if (SWIG_arg_fail(1)) SWIG_fail;
	2158	{
	2159	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2160	result = (bool)((wxAnimationPlayer const *)arg1)->UsingCustomBackgroundColour();
	2161
	2162	wxPyEndAllowThreads(__tstate);
	2163	if (PyErr_Occurred()) SWIG_fail;
	2164	}
	2165	{
	2166	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2167	}
	2168	return resultobj;
	2169	fail:
	2170	return NULL;
	2171	}
	2172
	2173
	2174	static PyObject _wrap_AnimationPlayer_GetCustomBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	2175	PyObject *resultobj;
	2176	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2177	wxColour *result;
	2178	PyObject * obj0 = 0 ;
	2179	char *kwnames[] = {
	2180	(char *) "self", NULL
	2181	};
	2182
	2183	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetCustomBackgroundColour",kwnames,&obj0)) goto fail;
	2184	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2185	if (SWIG_arg_fail(1)) SWIG_fail;
	2186	{
	2187	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2188	{
	2189	wxColour const &_result_ref = ((wxAnimationPlayer const *)arg1)->GetCustomBackgroundColour();
	2190	result = (wxColour *) &_result_ref;
	2191	}
	2192
	2193	wxPyEndAllowThreads(__tstate);
	2194	if (PyErr_Occurred()) SWIG_fail;
	2195	}
	2196	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
	2197	return resultobj;
	2198	fail:
	2199	return NULL;
	2200	}
	2201
	2202
	2203	static PyObject _wrap_AnimationPlayer_UseParentBackground(PyObject , PyObject args, PyObject kwargs) {
	2204	PyObject *resultobj;
	2205	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2206	bool arg2 ;
	2207	PyObject * obj0 = 0 ;
	2208	PyObject * obj1 = 0 ;
	2209	char *kwnames[] = {
	2210	(char ) "self",(char ) "useParent", NULL
	2211	};
	2212
	2213	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_UseParentBackground",kwnames,&obj0,&obj1)) goto fail;
	2214	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2215	if (SWIG_arg_fail(1)) SWIG_fail;
	2216	{
	2217	arg2 = (bool)(SWIG_As_bool(obj1));
	2218	if (SWIG_arg_fail(2)) SWIG_fail;
	2219	}
	2220	{
	2221	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2222	(arg1)->UseParentBackground(arg2);
	2223
	2224	wxPyEndAllowThreads(__tstate);
	2225	if (PyErr_Occurred()) SWIG_fail;
	2226	}
	2227	Py_INCREF(Py_None); resultobj = Py_None;
	2228	return resultobj;
	2229	fail:
	2230	return NULL;
	2231	}
	2232
	2233
	2234	static PyObject _wrap_AnimationPlayer_UsingParentBackground(PyObject , PyObject args, PyObject kwargs) {
	2235	PyObject *resultobj;
	2236	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2237	bool result;
	2238	PyObject * obj0 = 0 ;
	2239	char *kwnames[] = {
	2240	(char *) "self", NULL
	2241	};
	2242
	2243	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_UsingParentBackground",kwnames,&obj0)) goto fail;
	2244	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2245	if (SWIG_arg_fail(1)) SWIG_fail;
	2246	{
	2247	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2248	result = (bool)((wxAnimationPlayer const *)arg1)->UsingParentBackground();
	2249
	2250	wxPyEndAllowThreads(__tstate);
	2251	if (PyErr_Occurred()) SWIG_fail;
	2252	}
	2253	{
	2254	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2255	}
	2256	return resultobj;
	2257	fail:
	2258	return NULL;
	2259	}
	2260
	2261
	2262	static PyObject _wrap_AnimationPlayer_Play(PyObject , PyObject args, PyObject kwargs) {
	2263	PyObject *resultobj;
	2264	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2265	wxWindow *arg2 = 0 ;
	2266	wxPoint const &arg3_defvalue = wxPoint(0, 0) ;
	2267	wxPoint arg3 = (wxPoint ) &arg3_defvalue ;
	2268	bool arg4 = (bool) true ;
	2269	bool result;
	2270	wxPoint temp3 ;
	2271	PyObject * obj0 = 0 ;
	2272	PyObject * obj1 = 0 ;
	2273	PyObject * obj2 = 0 ;
	2274	PyObject * obj3 = 0 ;
	2275	char *kwnames[] = {
	2276	(char ) "self",(char ) "window",(char ) "pos",(char ) "looped", NULL
	2277	};
	2278
	2279	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO\|OO:AnimationPlayer_Play",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
	2280	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2281	if (SWIG_arg_fail(1)) SWIG_fail;
	2282	{
	2283	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	2284	if (SWIG_arg_fail(2)) SWIG_fail;
	2285	if (arg2 == NULL) {
	2286	SWIG_null_ref("wxWindow");
	2287	}
	2288	if (SWIG_arg_fail(2)) SWIG_fail;
	2289	}
	2290	if (obj2) {
	2291	{
	2292	arg3 = &temp3;
	2293	if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
	2294	}
	2295	}
	2296	if (obj3) {
	2297	{
	2298	arg4 = (bool)(SWIG_As_bool(obj3));
	2299	if (SWIG_arg_fail(4)) SWIG_fail;
	2300	}
	2301	}
	2302	{
	2303	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2304	result = (bool)(arg1)->Play(arg2,(wxPoint const &)arg3,arg4);
	2305
	2306	wxPyEndAllowThreads(__tstate);
	2307	if (PyErr_Occurred()) SWIG_fail;
	2308	}
	2309	{
	2310	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2311	}
	2312	return resultobj;
	2313	fail:
	2314	return NULL;
	2315	}
	2316
	2317
	2318	static PyObject _wrap_AnimationPlayer_Build(PyObject , PyObject args, PyObject kwargs) {
	2319	PyObject *resultobj;
	2320	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2321	bool result;
	2322	PyObject * obj0 = 0 ;
	2323	char *kwnames[] = {
	2324	(char *) "self", NULL
	2325	};
	2326
	2327	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_Build",kwnames,&obj0)) goto fail;
	2328	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2329	if (SWIG_arg_fail(1)) SWIG_fail;
	2330	{
	2331	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2332	result = (bool)(arg1)->Build();
	2333
	2334	wxPyEndAllowThreads(__tstate);
	2335	if (PyErr_Occurred()) SWIG_fail;
	2336	}
	2337	{
	2338	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2339	}
	2340	return resultobj;
	2341	fail:
	2342	return NULL;
	2343	}
	2344
	2345
	2346	static PyObject _wrap_AnimationPlayer_Stop(PyObject , PyObject args, PyObject kwargs) {
	2347	PyObject *resultobj;
	2348	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2349	PyObject * obj0 = 0 ;
	2350	char *kwnames[] = {
	2351	(char *) "self", NULL
	2352	};
	2353
	2354	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_Stop",kwnames,&obj0)) goto fail;
	2355	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2356	if (SWIG_arg_fail(1)) SWIG_fail;
	2357	{
	2358	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2359	(arg1)->Stop();
	2360
	2361	wxPyEndAllowThreads(__tstate);
	2362	if (PyErr_Occurred()) SWIG_fail;
	2363	}
	2364	Py_INCREF(Py_None); resultobj = Py_None;
	2365	return resultobj;
	2366	fail:
	2367	return NULL;
	2368	}
	2369
	2370
	2371	static PyObject _wrap_AnimationPlayer_Draw(PyObject , PyObject args, PyObject kwargs) {
	2372	PyObject *resultobj;
	2373	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2374	wxDC *arg2 = 0 ;
	2375	PyObject * obj0 = 0 ;
	2376	PyObject * obj1 = 0 ;
	2377	char *kwnames[] = {
	2378	(char ) "self",(char ) "dc", NULL
	2379	};
	2380
	2381	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_Draw",kwnames,&obj0,&obj1)) goto fail;
	2382	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2383	if (SWIG_arg_fail(1)) SWIG_fail;
	2384	{
	2385	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION \| 0);
	2386	if (SWIG_arg_fail(2)) SWIG_fail;
	2387	if (arg2 == NULL) {
	2388	SWIG_null_ref("wxDC");
	2389	}
	2390	if (SWIG_arg_fail(2)) SWIG_fail;
	2391	}
	2392	{
	2393	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2394	(arg1)->Draw(*arg2);
	2395
	2396	wxPyEndAllowThreads(__tstate);
	2397	if (PyErr_Occurred()) SWIG_fail;
	2398	}
	2399	Py_INCREF(Py_None); resultobj = Py_None;
	2400	return resultobj;
	2401	fail:
	2402	return NULL;
	2403	}
	2404
	2405
	2406	static PyObject _wrap_AnimationPlayer_GetFrameCount(PyObject , PyObject args, PyObject kwargs) {
	2407	PyObject *resultobj;
	2408	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2409	int result;
	2410	PyObject * obj0 = 0 ;
	2411	char *kwnames[] = {
	2412	(char *) "self", NULL
	2413	};
	2414
	2415	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetFrameCount",kwnames,&obj0)) goto fail;
	2416	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2417	if (SWIG_arg_fail(1)) SWIG_fail;
	2418	{
	2419	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2420	result = (int)((wxAnimationPlayer const *)arg1)->GetFrameCount();
	2421
	2422	wxPyEndAllowThreads(__tstate);
	2423	if (PyErr_Occurred()) SWIG_fail;
	2424	}
	2425	{
	2426	resultobj = SWIG_From_int((int)(result));
	2427	}
	2428	return resultobj;
	2429	fail:
	2430	return NULL;
	2431	}
	2432
	2433
	2434	static PyObject _wrap_AnimationPlayer_GetFrame(PyObject , PyObject args, PyObject kwargs) {
	2435	PyObject *resultobj;
	2436	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2437	int arg2 ;
	2438	wxImage *result;
	2439	PyObject * obj0 = 0 ;
	2440	PyObject * obj1 = 0 ;
	2441	char *kwnames[] = {
	2442	(char ) "self",(char ) "i", NULL
	2443	};
	2444
	2445	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetFrame",kwnames,&obj0,&obj1)) goto fail;
	2446	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2447	if (SWIG_arg_fail(1)) SWIG_fail;
	2448	{
	2449	arg2 = (int)(SWIG_As_int(obj1));
	2450	if (SWIG_arg_fail(2)) SWIG_fail;
	2451	}
	2452	{
	2453	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2454	result = (wxImage )((wxAnimationPlayer const )arg1)->GetFrame(arg2);
	2455
	2456	wxPyEndAllowThreads(__tstate);
	2457	if (PyErr_Occurred()) SWIG_fail;
	2458	}
	2459	{
	2460	resultobj = wxPyMake_wxObject(result, 1);
	2461	}
	2462	return resultobj;
	2463	fail:
	2464	return NULL;
	2465	}
	2466
	2467
	2468	static PyObject _wrap_AnimationPlayer_GetDisposalMethod(PyObject , PyObject args, PyObject kwargs) {
	2469	PyObject *resultobj;
	2470	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2471	int arg2 ;
	2472	wxAnimationDisposal result;
	2473	PyObject * obj0 = 0 ;
	2474	PyObject * obj1 = 0 ;
	2475	char *kwnames[] = {
	2476	(char ) "self",(char ) "i", NULL
	2477	};
	2478
	2479	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetDisposalMethod",kwnames,&obj0,&obj1)) goto fail;
	2480	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2481	if (SWIG_arg_fail(1)) SWIG_fail;
	2482	{
	2483	arg2 = (int)(SWIG_As_int(obj1));
	2484	if (SWIG_arg_fail(2)) SWIG_fail;
	2485	}
	2486	{
	2487	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2488	result = (wxAnimationDisposal)((wxAnimationPlayer const *)arg1)->GetDisposalMethod(arg2);
	2489
	2490	wxPyEndAllowThreads(__tstate);
	2491	if (PyErr_Occurred()) SWIG_fail;
	2492	}
	2493	resultobj = SWIG_From_int((result));
	2494	return resultobj;
	2495	fail:
	2496	return NULL;
	2497	}
	2498
	2499
	2500	static PyObject _wrap_AnimationPlayer_GetFrameRect(PyObject , PyObject args, PyObject kwargs) {
	2501	PyObject *resultobj;
	2502	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2503	int arg2 ;
	2504	wxRect result;
	2505	PyObject * obj0 = 0 ;
	2506	PyObject * obj1 = 0 ;
	2507	char *kwnames[] = {
	2508	(char ) "self",(char ) "i", NULL
	2509	};
	2510
	2511	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetFrameRect",kwnames,&obj0,&obj1)) goto fail;
	2512	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2513	if (SWIG_arg_fail(1)) SWIG_fail;
	2514	{
	2515	arg2 = (int)(SWIG_As_int(obj1));
	2516	if (SWIG_arg_fail(2)) SWIG_fail;
	2517	}
	2518	{
	2519	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2520	result = ((wxAnimationPlayer const *)arg1)->GetFrameRect(arg2);
	2521
	2522	wxPyEndAllowThreads(__tstate);
	2523	if (PyErr_Occurred()) SWIG_fail;
	2524	}
	2525	{
	2526	wxRect * resultptr;
	2527	resultptr = new wxRect((wxRect &)(result));
	2528	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
	2529	}
	2530	return resultobj;
	2531	fail:
	2532	return NULL;
	2533	}
	2534
	2535
	2536	static PyObject _wrap_AnimationPlayer_GetDelay(PyObject , PyObject args, PyObject kwargs) {
	2537	PyObject *resultobj;
	2538	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2539	int arg2 ;
	2540	int result;
	2541	PyObject * obj0 = 0 ;
	2542	PyObject * obj1 = 0 ;
	2543	char *kwnames[] = {
	2544	(char ) "self",(char ) "i", NULL
	2545	};
	2546
	2547	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetDelay",kwnames,&obj0,&obj1)) goto fail;
	2548	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2549	if (SWIG_arg_fail(1)) SWIG_fail;
	2550	{
	2551	arg2 = (int)(SWIG_As_int(obj1));
	2552	if (SWIG_arg_fail(2)) SWIG_fail;
	2553	}
	2554	{
	2555	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2556	result = (int)((wxAnimationPlayer const *)arg1)->GetDelay(arg2);
	2557
	2558	wxPyEndAllowThreads(__tstate);
	2559	if (PyErr_Occurred()) SWIG_fail;
	2560	}
	2561	{
	2562	resultobj = SWIG_From_int((int)(result));
	2563	}
	2564	return resultobj;
	2565	fail:
	2566	return NULL;
	2567	}
	2568
	2569
	2570	static PyObject _wrap_AnimationPlayer_GetLogicalScreenSize(PyObject , PyObject args, PyObject kwargs) {
	2571	PyObject *resultobj;
	2572	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2573	wxSize result;
	2574	PyObject * obj0 = 0 ;
	2575	char *kwnames[] = {
	2576	(char *) "self", NULL
	2577	};
	2578
	2579	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetLogicalScreenSize",kwnames,&obj0)) goto fail;
	2580	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2581	if (SWIG_arg_fail(1)) SWIG_fail;
	2582	{
	2583	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2584	result = ((wxAnimationPlayer const *)arg1)->GetLogicalScreenSize();
	2585
	2586	wxPyEndAllowThreads(__tstate);
	2587	if (PyErr_Occurred()) SWIG_fail;
	2588	}
	2589	{
	2590	wxSize * resultptr;
	2591	resultptr = new wxSize((wxSize &)(result));
	2592	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
	2593	}
	2594	return resultobj;
	2595	fail:
	2596	return NULL;
	2597	}
	2598
	2599
	2600	static PyObject _wrap_AnimationPlayer_GetBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	2601	PyObject *resultobj;
	2602	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2603	wxColour *arg2 = 0 ;
	2604	bool result;
	2605	wxColour temp2 ;
	2606	PyObject * obj0 = 0 ;
	2607	PyObject * obj1 = 0 ;
	2608	char *kwnames[] = {
	2609	(char ) "self",(char ) "col", NULL
	2610	};
	2611
	2612	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
	2613	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2614	if (SWIG_arg_fail(1)) SWIG_fail;
	2615	{
	2616	arg2 = &temp2;
	2617	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	2618	}
	2619	{
	2620	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2621	result = (bool)((wxAnimationPlayer const )arg1)->GetBackgroundColour(arg2);
	2622
	2623	wxPyEndAllowThreads(__tstate);
	2624	if (PyErr_Occurred()) SWIG_fail;
	2625	}
	2626	{
	2627	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2628	}
	2629	return resultobj;
	2630	fail:
	2631	return NULL;
	2632	}
	2633
	2634
	2635	static PyObject _wrap_AnimationPlayer_GetTransparentColour(PyObject , PyObject args, PyObject kwargs) {
	2636	PyObject *resultobj;
	2637	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2638	wxColour *arg2 = 0 ;
	2639	bool result;
	2640	wxColour temp2 ;
	2641	PyObject * obj0 = 0 ;
	2642	PyObject * obj1 = 0 ;
	2643	char *kwnames[] = {
	2644	(char ) "self",(char ) "col", NULL
	2645	};
	2646
	2647	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetTransparentColour",kwnames,&obj0,&obj1)) goto fail;
	2648	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2649	if (SWIG_arg_fail(1)) SWIG_fail;
	2650	{
	2651	arg2 = &temp2;
	2652	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	2653	}
	2654	{
	2655	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2656	result = (bool)((wxAnimationPlayer const )arg1)->GetTransparentColour(arg2);
	2657
	2658	wxPyEndAllowThreads(__tstate);
	2659	if (PyErr_Occurred()) SWIG_fail;
	2660	}
	2661	{
	2662	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2663	}
	2664	return resultobj;
	2665	fail:
	2666	return NULL;
	2667	}
	2668
	2669
	2670	static PyObject _wrap_AnimationPlayer_PlayFrame(PyObject , PyObject args, PyObject kwargs) {
	2671	PyObject *resultobj;
	2672	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2673	int arg2 ;
	2674	wxWindow *arg3 = 0 ;
	2675	wxPoint *arg4 = 0 ;
	2676	bool result;
	2677	wxPoint temp4 ;
	2678	PyObject * obj0 = 0 ;
	2679	PyObject * obj1 = 0 ;
	2680	PyObject * obj2 = 0 ;
	2681	PyObject * obj3 = 0 ;
	2682	char *kwnames[] = {
	2683	(char ) "self",(char ) "frame",(char ) "window",(char ) "pos", NULL
	2684	};
	2685
	2686	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AnimationPlayer_PlayFrame",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
	2687	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2688	if (SWIG_arg_fail(1)) SWIG_fail;
	2689	{
	2690	arg2 = (int)(SWIG_As_int(obj1));
	2691	if (SWIG_arg_fail(2)) SWIG_fail;
	2692	}
	2693	{
	2694	SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	2695	if (SWIG_arg_fail(3)) SWIG_fail;
	2696	if (arg3 == NULL) {
	2697	SWIG_null_ref("wxWindow");
	2698	}
	2699	if (SWIG_arg_fail(3)) SWIG_fail;
	2700	}
	2701	{
	2702	arg4 = &temp4;
	2703	if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
	2704	}
	2705	{
	2706	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2707	result = (bool)(arg1)->PlayFrame(arg2,arg3,(wxPoint const &)arg4);
	2708
	2709	wxPyEndAllowThreads(__tstate);
	2710	if (PyErr_Occurred()) SWIG_fail;
	2711	}
	2712	{
	2713	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2714	}
	2715	return resultobj;
	2716	fail:
	2717	return NULL;
	2718	}
	2719
	2720
	2721	static PyObject _wrap_AnimationPlayer_PlayNextFrame(PyObject , PyObject args, PyObject kwargs) {
	2722	PyObject *resultobj;
	2723	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2724	bool result;
	2725	PyObject * obj0 = 0 ;
	2726	char *kwnames[] = {
	2727	(char *) "self", NULL
	2728	};
	2729
	2730	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_PlayNextFrame",kwnames,&obj0)) goto fail;
	2731	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2732	if (SWIG_arg_fail(1)) SWIG_fail;
	2733	{
	2734	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2735	result = (bool)(arg1)->PlayFrame();
	2736
	2737	wxPyEndAllowThreads(__tstate);
	2738	if (PyErr_Occurred()) SWIG_fail;
	2739	}
	2740	{
	2741	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2742	}
	2743	return resultobj;
	2744	fail:
	2745	return NULL;
	2746	}
	2747
	2748
	2749	static PyObject _wrap_AnimationPlayer_DrawFrame(PyObject , PyObject args, PyObject kwargs) {
	2750	PyObject *resultobj;
	2751	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2752	int arg2 ;
	2753	wxDC *arg3 = 0 ;
	2754	wxPoint *arg4 = 0 ;
	2755	wxPoint temp4 ;
	2756	PyObject * obj0 = 0 ;
	2757	PyObject * obj1 = 0 ;
	2758	PyObject * obj2 = 0 ;
	2759	PyObject * obj3 = 0 ;
	2760	char *kwnames[] = {
	2761	(char ) "self",(char ) "frame",(char ) "dc",(char ) "pos", NULL
	2762	};
	2763
	2764	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AnimationPlayer_DrawFrame",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
	2765	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2766	if (SWIG_arg_fail(1)) SWIG_fail;
	2767	{
	2768	arg2 = (int)(SWIG_As_int(obj1));
	2769	if (SWIG_arg_fail(2)) SWIG_fail;
	2770	}
	2771	{
	2772	SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION \| 0);
	2773	if (SWIG_arg_fail(3)) SWIG_fail;
	2774	if (arg3 == NULL) {
	2775	SWIG_null_ref("wxDC");
	2776	}
	2777	if (SWIG_arg_fail(3)) SWIG_fail;
	2778	}
	2779	{
	2780	arg4 = &temp4;
	2781	if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
	2782	}
	2783	{
	2784	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2785	(arg1)->DrawFrame(arg2,arg3,(wxPoint const &)arg4);
	2786
	2787	wxPyEndAllowThreads(__tstate);
	2788	if (PyErr_Occurred()) SWIG_fail;
	2789	}
	2790	Py_INCREF(Py_None); resultobj = Py_None;
	2791	return resultobj;
	2792	fail:
	2793	return NULL;
	2794	}
	2795
	2796
	2797	static PyObject _wrap_AnimationPlayer_DrawBackground(PyObject , PyObject args, PyObject kwargs) {
	2798	PyObject *resultobj;
	2799	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2800	wxDC *arg2 = 0 ;
	2801	wxPoint *arg3 = 0 ;
	2802	wxColour *arg4 = 0 ;
	2803	wxPoint temp3 ;
	2804	wxColour temp4 ;
	2805	PyObject * obj0 = 0 ;
	2806	PyObject * obj1 = 0 ;
	2807	PyObject * obj2 = 0 ;
	2808	PyObject * obj3 = 0 ;
	2809	char *kwnames[] = {
	2810	(char ) "self",(char ) "dc",(char ) "pos",(char ) "colour", NULL
	2811	};
	2812
	2813	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AnimationPlayer_DrawBackground",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
	2814	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2815	if (SWIG_arg_fail(1)) SWIG_fail;
	2816	{
	2817	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION \| 0);
	2818	if (SWIG_arg_fail(2)) SWIG_fail;
	2819	if (arg2 == NULL) {
	2820	SWIG_null_ref("wxDC");
	2821	}
	2822	if (SWIG_arg_fail(2)) SWIG_fail;
	2823	}
	2824	{
	2825	arg3 = &temp3;
	2826	if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
	2827	}
	2828	{
	2829	arg4 = &temp4;
	2830	if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
	2831	}
	2832	{
	2833	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2834	(arg1)->DrawBackground(arg2,(wxPoint const &)arg3,(wxColour const &)*arg4);
	2835
	2836	wxPyEndAllowThreads(__tstate);
	2837	if (PyErr_Occurred()) SWIG_fail;
	2838	}
	2839	Py_INCREF(Py_None); resultobj = Py_None;
	2840	return resultobj;
	2841	fail:
	2842	return NULL;
	2843	}
	2844
	2845
	2846	static PyObject _wrap_AnimationPlayer_ClearCache(PyObject , PyObject args, PyObject kwargs) {
	2847	PyObject *resultobj;
	2848	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2849	PyObject * obj0 = 0 ;
	2850	char *kwnames[] = {
	2851	(char *) "self", NULL
	2852	};
	2853
	2854	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_ClearCache",kwnames,&obj0)) goto fail;
	2855	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2856	if (SWIG_arg_fail(1)) SWIG_fail;
	2857	{
	2858	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2859	(arg1)->ClearCache();
	2860
	2861	wxPyEndAllowThreads(__tstate);
	2862	if (PyErr_Occurred()) SWIG_fail;
	2863	}
	2864	Py_INCREF(Py_None); resultobj = Py_None;
	2865	return resultobj;
	2866	fail:
	2867	return NULL;
	2868	}
	2869
	2870
	2871	static PyObject _wrap_AnimationPlayer_SaveBackground(PyObject , PyObject args, PyObject kwargs) {
	2872	PyObject *resultobj;
	2873	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2874	wxRect *arg2 = 0 ;
	2875	wxRect temp2 ;
	2876	PyObject * obj0 = 0 ;
	2877	PyObject * obj1 = 0 ;
	2878	char *kwnames[] = {
	2879	(char ) "self",(char ) "rect", NULL
	2880	};
	2881
	2882	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_SaveBackground",kwnames,&obj0,&obj1)) goto fail;
	2883	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2884	if (SWIG_arg_fail(1)) SWIG_fail;
	2885	{
	2886	arg2 = &temp2;
	2887	if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
	2888	}
	2889	{
	2890	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2891	(arg1)->SaveBackground((wxRect const &)*arg2);
	2892
	2893	wxPyEndAllowThreads(__tstate);
	2894	if (PyErr_Occurred()) SWIG_fail;
	2895	}
	2896	Py_INCREF(Py_None); resultobj = Py_None;
	2897	return resultobj;
	2898	fail:
	2899	return NULL;
	2900	}
	2901
	2902
	2903	static PyObject _wrap_AnimationPlayer_GetBackingStore(PyObject , PyObject args, PyObject kwargs) {
	2904	PyObject *resultobj;
	2905	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2906	wxBitmap *result;
	2907	PyObject * obj0 = 0 ;
	2908	char *kwnames[] = {
	2909	(char *) "self", NULL
	2910	};
	2911
	2912	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetBackingStore",kwnames,&obj0)) goto fail;
	2913	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2914	if (SWIG_arg_fail(1)) SWIG_fail;
	2915	{
	2916	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2917	{
	2918	wxBitmap &_result_ref = (arg1)->GetBackingStore();
	2919	result = (wxBitmap *) &_result_ref;
	2920	}
	2921
	2922	wxPyEndAllowThreads(__tstate);
	2923	if (PyErr_Occurred()) SWIG_fail;
	2924	}
	2925	{
	2926	wxBitmap* resultptr = new wxBitmap(*result);
	2927	resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
	2928	}
	2929	return resultobj;
	2930	fail:
	2931	return NULL;
	2932	}
	2933
	2934
	2935	static PyObject * AnimationPlayer_swigregister(PyObject , PyObject args) {
	2936	PyObject *obj;
	2937	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	2938	SWIG_TypeClientData(SWIGTYPE_p_wxAnimationPlayer, obj);
	2939	Py_INCREF(obj);
	2940	return Py_BuildValue((char *)"");
	2941	}
	2942	static PyObject _wrap_delete_AnimationBase(PyObject , PyObject args, PyObject kwargs) {
	2943	PyObject *resultobj;
	2944	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	2945	PyObject * obj0 = 0 ;
	2946	char *kwnames[] = {
	2947	(char *) "self", NULL
	2948	};
	2949
	2950	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AnimationBase",kwnames,&obj0)) goto fail;
	2951	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	2952	if (SWIG_arg_fail(1)) SWIG_fail;
	2953	{
	2954	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2955	delete arg1;
	2956
	2957	wxPyEndAllowThreads(__tstate);
	2958	if (PyErr_Occurred()) SWIG_fail;
	2959	}
	2960	Py_INCREF(Py_None); resultobj = Py_None;
	2961	return resultobj;
	2962	fail:
	2963	return NULL;
	2964	}
	2965
	2966
	2967	static PyObject _wrap_AnimationBase_GetFrameCount(PyObject , PyObject args, PyObject kwargs) {
	2968	PyObject *resultobj;
	2969	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	2970	int result;
	2971	PyObject * obj0 = 0 ;
	2972	char *kwnames[] = {
	2973	(char *) "self", NULL
	2974	};
	2975
	2976	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationBase_GetFrameCount",kwnames,&obj0)) goto fail;
	2977	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	2978	if (SWIG_arg_fail(1)) SWIG_fail;
	2979	{
	2980	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2981	result = (int)((wxAnimationBase const *)arg1)->GetFrameCount();
	2982
	2983	wxPyEndAllowThreads(__tstate);
	2984	if (PyErr_Occurred()) SWIG_fail;
	2985	}
	2986	{
	2987	resultobj = SWIG_From_int((int)(result));
	2988	}
	2989	return resultobj;
	2990	fail:
	2991	return NULL;
	2992	}
	2993
	2994
	2995	static PyObject _wrap_AnimationBase_GetFrame(PyObject , PyObject args, PyObject kwargs) {
	2996	PyObject *resultobj;
	2997	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	2998	int arg2 ;
	2999	wxImage *result;
	3000	PyObject * obj0 = 0 ;
	3001	PyObject * obj1 = 0 ;
	3002	char *kwnames[] = {
	3003	(char ) "self",(char ) "i", NULL
	3004	};
	3005
	3006	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetFrame",kwnames,&obj0,&obj1)) goto fail;
	3007	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3008	if (SWIG_arg_fail(1)) SWIG_fail;
	3009	{
	3010	arg2 = (int)(SWIG_As_int(obj1));
	3011	if (SWIG_arg_fail(2)) SWIG_fail;
	3012	}
	3013	{
	3014	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3015	result = (wxImage )((wxAnimationBase const )arg1)->GetFrame(arg2);
	3016
	3017	wxPyEndAllowThreads(__tstate);
	3018	if (PyErr_Occurred()) SWIG_fail;
	3019	}
	3020	{
	3021	resultobj = wxPyMake_wxObject(result, 1);
	3022	}
	3023	return resultobj;
	3024	fail:
	3025	return NULL;
	3026	}
	3027
	3028
	3029	static PyObject _wrap_AnimationBase_GetDisposalMethod(PyObject , PyObject args, PyObject kwargs) {
	3030	PyObject *resultobj;
	3031	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3032	int arg2 ;
	3033	wxAnimationDisposal result;
	3034	PyObject * obj0 = 0 ;
	3035	PyObject * obj1 = 0 ;
	3036	char *kwnames[] = {
	3037	(char ) "self",(char ) "i", NULL
	3038	};
	3039
	3040	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetDisposalMethod",kwnames,&obj0,&obj1)) goto fail;
	3041	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3042	if (SWIG_arg_fail(1)) SWIG_fail;
	3043	{
	3044	arg2 = (int)(SWIG_As_int(obj1));
	3045	if (SWIG_arg_fail(2)) SWIG_fail;
	3046	}
	3047	{
	3048	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3049	result = (wxAnimationDisposal)((wxAnimationBase const *)arg1)->GetDisposalMethod(arg2);
	3050
	3051	wxPyEndAllowThreads(__tstate);
	3052	if (PyErr_Occurred()) SWIG_fail;
	3053	}
	3054	resultobj = SWIG_From_int((result));
	3055	return resultobj;
	3056	fail:
	3057	return NULL;
	3058	}
	3059
	3060
	3061	static PyObject _wrap_AnimationBase_GetFrameRect(PyObject , PyObject args, PyObject kwargs) {
	3062	PyObject *resultobj;
	3063	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3064	int arg2 ;
	3065	wxRect result;
	3066	PyObject * obj0 = 0 ;
	3067	PyObject * obj1 = 0 ;
	3068	char *kwnames[] = {
	3069	(char ) "self",(char ) "i", NULL
	3070	};
	3071
	3072	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetFrameRect",kwnames,&obj0,&obj1)) goto fail;
	3073	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3074	if (SWIG_arg_fail(1)) SWIG_fail;
	3075	{
	3076	arg2 = (int)(SWIG_As_int(obj1));
	3077	if (SWIG_arg_fail(2)) SWIG_fail;
	3078	}
	3079	{
	3080	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3081	result = ((wxAnimationBase const *)arg1)->GetFrameRect(arg2);
	3082
	3083	wxPyEndAllowThreads(__tstate);
	3084	if (PyErr_Occurred()) SWIG_fail;
	3085	}
	3086	{
	3087	wxRect * resultptr;
	3088	resultptr = new wxRect((wxRect &)(result));
	3089	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
	3090	}
	3091	return resultobj;
	3092	fail:
	3093	return NULL;
	3094	}
	3095
	3096
	3097	static PyObject _wrap_AnimationBase_GetDelay(PyObject , PyObject args, PyObject kwargs) {
	3098	PyObject *resultobj;
	3099	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3100	int arg2 ;
	3101	int result;
	3102	PyObject * obj0 = 0 ;
	3103	PyObject * obj1 = 0 ;
	3104	char *kwnames[] = {
	3105	(char ) "self",(char ) "i", NULL
	3106	};
	3107
	3108	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetDelay",kwnames,&obj0,&obj1)) goto fail;
	3109	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3110	if (SWIG_arg_fail(1)) SWIG_fail;
	3111	{
	3112	arg2 = (int)(SWIG_As_int(obj1));
	3113	if (SWIG_arg_fail(2)) SWIG_fail;
	3114	}
	3115	{
	3116	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3117	result = (int)((wxAnimationBase const *)arg1)->GetDelay(arg2);
	3118
	3119	wxPyEndAllowThreads(__tstate);
	3120	if (PyErr_Occurred()) SWIG_fail;
	3121	}
	3122	{
	3123	resultobj = SWIG_From_int((int)(result));
	3124	}
	3125	return resultobj;
	3126	fail:
	3127	return NULL;
	3128	}
	3129
	3130
	3131	static PyObject _wrap_AnimationBase_GetLogicalScreenSize(PyObject , PyObject args, PyObject kwargs) {
	3132	PyObject *resultobj;
	3133	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3134	wxSize result;
	3135	PyObject * obj0 = 0 ;
	3136	char *kwnames[] = {
	3137	(char *) "self", NULL
	3138	};
	3139
	3140	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationBase_GetLogicalScreenSize",kwnames,&obj0)) goto fail;
	3141	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3142	if (SWIG_arg_fail(1)) SWIG_fail;
	3143	{
	3144	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3145	result = ((wxAnimationBase const *)arg1)->GetLogicalScreenSize();
	3146
	3147	wxPyEndAllowThreads(__tstate);
	3148	if (PyErr_Occurred()) SWIG_fail;
	3149	}
	3150	{
	3151	wxSize * resultptr;
	3152	resultptr = new wxSize((wxSize &)(result));
	3153	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
	3154	}
	3155	return resultobj;
	3156	fail:
	3157	return NULL;
	3158	}
	3159
	3160
	3161	static PyObject _wrap_AnimationBase_GetBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	3162	PyObject *resultobj;
	3163	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3164	wxColour *arg2 = 0 ;
	3165	bool result;
	3166	wxColour temp2 ;
	3167	PyObject * obj0 = 0 ;
	3168	PyObject * obj1 = 0 ;
	3169	char *kwnames[] = {
	3170	(char ) "self",(char ) "col", NULL
	3171	};
	3172
	3173	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
	3174	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3175	if (SWIG_arg_fail(1)) SWIG_fail;
	3176	{
	3177	arg2 = &temp2;
	3178	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3179	}
	3180	{
	3181	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3182	result = (bool)((wxAnimationBase const )arg1)->GetBackgroundColour(arg2);
	3183
	3184	wxPyEndAllowThreads(__tstate);
	3185	if (PyErr_Occurred()) SWIG_fail;
	3186	}
	3187	{
	3188	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3189	}
	3190	return resultobj;
	3191	fail:
	3192	return NULL;
	3193	}
	3194
	3195
	3196	static PyObject _wrap_AnimationBase_GetTransparentColour(PyObject , PyObject args, PyObject kwargs) {
	3197	PyObject *resultobj;
	3198	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3199	wxColour *arg2 = 0 ;
	3200	bool result;
	3201	wxColour temp2 ;
	3202	PyObject * obj0 = 0 ;
	3203	PyObject * obj1 = 0 ;
	3204	char *kwnames[] = {
	3205	(char ) "self",(char ) "col", NULL
	3206	};
	3207
	3208	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetTransparentColour",kwnames,&obj0,&obj1)) goto fail;
	3209	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3210	if (SWIG_arg_fail(1)) SWIG_fail;
	3211	{
	3212	arg2 = &temp2;
	3213	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3214	}
	3215	{
	3216	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3217	result = (bool)((wxAnimationBase const )arg1)->GetTransparentColour(arg2);
	3218
	3219	wxPyEndAllowThreads(__tstate);
	3220	if (PyErr_Occurred()) SWIG_fail;
	3221	}
	3222	{
	3223	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3224	}
	3225	return resultobj;
	3226	fail:
	3227	return NULL;
	3228	}
	3229
	3230
	3231	static PyObject _wrap_AnimationBase_IsValid(PyObject , PyObject args, PyObject kwargs) {
	3232	PyObject *resultobj;
	3233	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3234	bool result;
	3235	PyObject * obj0 = 0 ;
	3236	char *kwnames[] = {
	3237	(char *) "self", NULL
	3238	};
	3239
	3240	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationBase_IsValid",kwnames,&obj0)) goto fail;
	3241	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3242	if (SWIG_arg_fail(1)) SWIG_fail;
	3243	{
	3244	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3245	result = (bool)((wxAnimationBase const *)arg1)->IsValid();
	3246
	3247	wxPyEndAllowThreads(__tstate);
	3248	if (PyErr_Occurred()) SWIG_fail;
	3249	}
	3250	{
	3251	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3252	}
	3253	return resultobj;
	3254	fail:
	3255	return NULL;
	3256	}
	3257
	3258
	3259	static PyObject _wrap_AnimationBase_LoadFile(PyObject , PyObject args, PyObject kwargs) {
	3260	PyObject *resultobj;
	3261	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3262	wxString *arg2 = 0 ;
	3263	bool result;
	3264	bool temp2 = false ;
	3265	PyObject * obj0 = 0 ;
	3266	PyObject * obj1 = 0 ;
	3267	char *kwnames[] = {
	3268	(char ) "self",(char ) "filename", NULL
	3269	};
	3270
	3271	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_LoadFile",kwnames,&obj0,&obj1)) goto fail;
	3272	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3273	if (SWIG_arg_fail(1)) SWIG_fail;
	3274	{
	3275	arg2 = wxString_in_helper(obj1);
	3276	if (arg2 == NULL) SWIG_fail;
	3277	temp2 = true;
	3278	}
	3279	{
	3280	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3281	result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
	3282
	3283	wxPyEndAllowThreads(__tstate);
	3284	if (PyErr_Occurred()) SWIG_fail;
	3285	}
	3286	{
	3287	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3288	}
	3289	{
	3290	if (temp2)
	3291	delete arg2;
	3292	}
	3293	return resultobj;
	3294	fail:
	3295	{
	3296	if (temp2)
	3297	delete arg2;
	3298	}
	3299	return NULL;
	3300	}
	3301
	3302
	3303	static PyObject * AnimationBase_swigregister(PyObject , PyObject args) {
	3304	PyObject *obj;
	3305	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	3306	SWIG_TypeClientData(SWIGTYPE_p_wxAnimationBase, obj);
	3307	Py_INCREF(obj);
	3308	return Py_BuildValue((char *)"");
	3309	}
	3310	static PyObject _wrap_new_GIFAnimation(PyObject , PyObject args, PyObject kwargs) {
	3311	PyObject *resultobj;
	3312	wxGIFAnimation *result;
	3313	char *kwnames[] = {
	3314	NULL
	3315	};
	3316
	3317	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFAnimation",kwnames)) goto fail;
	3318	{
	3319	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3320	result = (wxGIFAnimation *)new wxGIFAnimation();
	3321
	3322	wxPyEndAllowThreads(__tstate);
	3323	if (PyErr_Occurred()) SWIG_fail;
	3324	}
	3325	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFAnimation, 1);
	3326	return resultobj;
	3327	fail:
	3328	return NULL;
	3329	}
	3330
	3331
	3332	static PyObject _wrap_delete_GIFAnimation(PyObject , PyObject args, PyObject kwargs) {
	3333	PyObject *resultobj;
	3334	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3335	PyObject * obj0 = 0 ;
	3336	char *kwnames[] = {
	3337	(char *) "self", NULL
	3338	};
	3339
	3340	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GIFAnimation",kwnames,&obj0)) goto fail;
	3341	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3342	if (SWIG_arg_fail(1)) SWIG_fail;
	3343	{
	3344	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3345	delete arg1;
	3346
	3347	wxPyEndAllowThreads(__tstate);
	3348	if (PyErr_Occurred()) SWIG_fail;
	3349	}
	3350	Py_INCREF(Py_None); resultobj = Py_None;
	3351	return resultobj;
	3352	fail:
	3353	return NULL;
	3354	}
	3355
	3356
	3357	static PyObject _wrap_GIFAnimation_GetFrameCount(PyObject , PyObject args, PyObject kwargs) {
	3358	PyObject *resultobj;
	3359	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3360	int result;
	3361	PyObject * obj0 = 0 ;
	3362	char *kwnames[] = {
	3363	(char *) "self", NULL
	3364	};
	3365
	3366	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimation_GetFrameCount",kwnames,&obj0)) goto fail;
	3367	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3368	if (SWIG_arg_fail(1)) SWIG_fail;
	3369	{
	3370	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3371	result = (int)((wxGIFAnimation const *)arg1)->GetFrameCount();
	3372
	3373	wxPyEndAllowThreads(__tstate);
	3374	if (PyErr_Occurred()) SWIG_fail;
	3375	}
	3376	{
	3377	resultobj = SWIG_From_int((int)(result));
	3378	}
	3379	return resultobj;
	3380	fail:
	3381	return NULL;
	3382	}
	3383
	3384
	3385	static PyObject _wrap_GIFAnimation_GetFrame(PyObject , PyObject args, PyObject kwargs) {
	3386	PyObject *resultobj;
	3387	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3388	int arg2 ;
	3389	wxImage *result;
	3390	PyObject * obj0 = 0 ;
	3391	PyObject * obj1 = 0 ;
	3392	char *kwnames[] = {
	3393	(char ) "self",(char ) "i", NULL
	3394	};
	3395
	3396	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetFrame",kwnames,&obj0,&obj1)) goto fail;
	3397	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3398	if (SWIG_arg_fail(1)) SWIG_fail;
	3399	{
	3400	arg2 = (int)(SWIG_As_int(obj1));
	3401	if (SWIG_arg_fail(2)) SWIG_fail;
	3402	}
	3403	{
	3404	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3405	result = (wxImage )((wxGIFAnimation const )arg1)->GetFrame(arg2);
	3406
	3407	wxPyEndAllowThreads(__tstate);
	3408	if (PyErr_Occurred()) SWIG_fail;
	3409	}
	3410	{
	3411	resultobj = wxPyMake_wxObject(result, 1);
	3412	}
	3413	return resultobj;
	3414	fail:
	3415	return NULL;
	3416	}
	3417
	3418
	3419	static PyObject _wrap_GIFAnimation_GetDisposalMethod(PyObject , PyObject args, PyObject kwargs) {
	3420	PyObject *resultobj;
	3421	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3422	int arg2 ;
	3423	wxAnimationDisposal result;
	3424	PyObject * obj0 = 0 ;
	3425	PyObject * obj1 = 0 ;
	3426	char *kwnames[] = {
	3427	(char ) "self",(char ) "i", NULL
	3428	};
	3429
	3430	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetDisposalMethod",kwnames,&obj0,&obj1)) goto fail;
	3431	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3432	if (SWIG_arg_fail(1)) SWIG_fail;
	3433	{
	3434	arg2 = (int)(SWIG_As_int(obj1));
	3435	if (SWIG_arg_fail(2)) SWIG_fail;
	3436	}
	3437	{
	3438	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3439	result = (wxAnimationDisposal)((wxGIFAnimation const *)arg1)->GetDisposalMethod(arg2);
	3440
	3441	wxPyEndAllowThreads(__tstate);
	3442	if (PyErr_Occurred()) SWIG_fail;
	3443	}
	3444	resultobj = SWIG_From_int((result));
	3445	return resultobj;
	3446	fail:
	3447	return NULL;
	3448	}
	3449
	3450
	3451	static PyObject _wrap_GIFAnimation_GetFrameRect(PyObject , PyObject args, PyObject kwargs) {
	3452	PyObject *resultobj;
	3453	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3454	int arg2 ;
	3455	wxRect result;
	3456	PyObject * obj0 = 0 ;
	3457	PyObject * obj1 = 0 ;
	3458	char *kwnames[] = {
	3459	(char ) "self",(char ) "i", NULL
	3460	};
	3461
	3462	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetFrameRect",kwnames,&obj0,&obj1)) goto fail;
	3463	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3464	if (SWIG_arg_fail(1)) SWIG_fail;
	3465	{
	3466	arg2 = (int)(SWIG_As_int(obj1));
	3467	if (SWIG_arg_fail(2)) SWIG_fail;
	3468	}
	3469	{
	3470	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3471	result = ((wxGIFAnimation const *)arg1)->GetFrameRect(arg2);
	3472
	3473	wxPyEndAllowThreads(__tstate);
	3474	if (PyErr_Occurred()) SWIG_fail;
	3475	}
	3476	{
	3477	wxRect * resultptr;
	3478	resultptr = new wxRect((wxRect &)(result));
	3479	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
	3480	}
	3481	return resultobj;
	3482	fail:
	3483	return NULL;
	3484	}
	3485
	3486
	3487	static PyObject _wrap_GIFAnimation_GetDelay(PyObject , PyObject args, PyObject kwargs) {
	3488	PyObject *resultobj;
	3489	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3490	int arg2 ;
	3491	int result;
	3492	PyObject * obj0 = 0 ;
	3493	PyObject * obj1 = 0 ;
	3494	char *kwnames[] = {
	3495	(char ) "self",(char ) "i", NULL
	3496	};
	3497
	3498	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetDelay",kwnames,&obj0,&obj1)) goto fail;
	3499	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3500	if (SWIG_arg_fail(1)) SWIG_fail;
	3501	{
	3502	arg2 = (int)(SWIG_As_int(obj1));
	3503	if (SWIG_arg_fail(2)) SWIG_fail;
	3504	}
	3505	{
	3506	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3507	result = (int)((wxGIFAnimation const *)arg1)->GetDelay(arg2);
	3508
	3509	wxPyEndAllowThreads(__tstate);
	3510	if (PyErr_Occurred()) SWIG_fail;
	3511	}
	3512	{
	3513	resultobj = SWIG_From_int((int)(result));
	3514	}
	3515	return resultobj;
	3516	fail:
	3517	return NULL;
	3518	}
	3519
	3520
	3521	static PyObject _wrap_GIFAnimation_GetLogicalScreenSize(PyObject , PyObject args, PyObject kwargs) {
	3522	PyObject *resultobj;
	3523	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3524	wxSize result;
	3525	PyObject * obj0 = 0 ;
	3526	char *kwnames[] = {
	3527	(char *) "self", NULL
	3528	};
	3529
	3530	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimation_GetLogicalScreenSize",kwnames,&obj0)) goto fail;
	3531	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3532	if (SWIG_arg_fail(1)) SWIG_fail;
	3533	{
	3534	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3535	result = ((wxGIFAnimation const *)arg1)->GetLogicalScreenSize();
	3536
	3537	wxPyEndAllowThreads(__tstate);
	3538	if (PyErr_Occurred()) SWIG_fail;
	3539	}
	3540	{
	3541	wxSize * resultptr;
	3542	resultptr = new wxSize((wxSize &)(result));
	3543	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
	3544	}
	3545	return resultobj;
	3546	fail:
	3547	return NULL;
	3548	}
	3549
	3550
	3551	static PyObject _wrap_GIFAnimation_GetBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	3552	PyObject *resultobj;
	3553	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3554	wxColour *arg2 = 0 ;
	3555	bool result;
	3556	wxColour temp2 ;
	3557	PyObject * obj0 = 0 ;
	3558	PyObject * obj1 = 0 ;
	3559	char *kwnames[] = {
	3560	(char ) "self",(char ) "col", NULL
	3561	};
	3562
	3563	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
	3564	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3565	if (SWIG_arg_fail(1)) SWIG_fail;
	3566	{
	3567	arg2 = &temp2;
	3568	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3569	}
	3570	{
	3571	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3572	result = (bool)((wxGIFAnimation const )arg1)->GetBackgroundColour(arg2);
	3573
	3574	wxPyEndAllowThreads(__tstate);
	3575	if (PyErr_Occurred()) SWIG_fail;
	3576	}
	3577	{
	3578	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3579	}
	3580	return resultobj;
	3581	fail:
	3582	return NULL;
	3583	}
	3584
	3585
	3586	static PyObject _wrap_GIFAnimation_GetTransparentColour(PyObject , PyObject args, PyObject kwargs) {
	3587	PyObject *resultobj;
	3588	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3589	wxColour *arg2 = 0 ;
	3590	bool result;
	3591	wxColour temp2 ;
	3592	PyObject * obj0 = 0 ;
	3593	PyObject * obj1 = 0 ;
	3594	char *kwnames[] = {
	3595	(char ) "self",(char ) "col", NULL
	3596	};
	3597
	3598	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetTransparentColour",kwnames,&obj0,&obj1)) goto fail;
	3599	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3600	if (SWIG_arg_fail(1)) SWIG_fail;
	3601	{
	3602	arg2 = &temp2;
	3603	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3604	}
	3605	{
	3606	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3607	result = (bool)((wxGIFAnimation const )arg1)->GetTransparentColour(arg2);
	3608
	3609	wxPyEndAllowThreads(__tstate);
	3610	if (PyErr_Occurred()) SWIG_fail;
	3611	}
	3612	{
	3613	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3614	}
	3615	return resultobj;
	3616	fail:
	3617	return NULL;
	3618	}
	3619
	3620
	3621	static PyObject _wrap_GIFAnimation_IsValid(PyObject , PyObject args, PyObject kwargs) {
	3622	PyObject *resultobj;
	3623	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3624	bool result;
	3625	PyObject * obj0 = 0 ;
	3626	char *kwnames[] = {
	3627	(char *) "self", NULL
	3628	};
	3629
	3630	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimation_IsValid",kwnames,&obj0)) goto fail;
	3631	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3632	if (SWIG_arg_fail(1)) SWIG_fail;
	3633	{
	3634	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3635	result = (bool)((wxGIFAnimation const *)arg1)->IsValid();
	3636
	3637	wxPyEndAllowThreads(__tstate);
	3638	if (PyErr_Occurred()) SWIG_fail;
	3639	}
	3640	{
	3641	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3642	}
	3643	return resultobj;
	3644	fail:
	3645	return NULL;
	3646	}
	3647
	3648
	3649	static PyObject _wrap_GIFAnimation_LoadFile(PyObject , PyObject args, PyObject kwargs) {
	3650	PyObject *resultobj;
	3651	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3652	wxString *arg2 = 0 ;
	3653	bool result;
	3654	bool temp2 = false ;
	3655	PyObject * obj0 = 0 ;
	3656	PyObject * obj1 = 0 ;
	3657	char *kwnames[] = {
	3658	(char ) "self",(char ) "filename", NULL
	3659	};
	3660
	3661	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_LoadFile",kwnames,&obj0,&obj1)) goto fail;
	3662	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3663	if (SWIG_arg_fail(1)) SWIG_fail;
	3664	{
	3665	arg2 = wxString_in_helper(obj1);
	3666	if (arg2 == NULL) SWIG_fail;
	3667	temp2 = true;
	3668	}
	3669	{
	3670	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3671	result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
	3672
	3673	wxPyEndAllowThreads(__tstate);
	3674	if (PyErr_Occurred()) SWIG_fail;
	3675	}
	3676	{
	3677	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3678	}
	3679	{
	3680	if (temp2)
	3681	delete arg2;
	3682	}
	3683	return resultobj;
	3684	fail:
	3685	{
	3686	if (temp2)
	3687	delete arg2;
	3688	}
	3689	return NULL;
	3690	}
	3691
	3692
	3693	static PyObject * GIFAnimation_swigregister(PyObject , PyObject args) {
	3694	PyObject *obj;
	3695	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	3696	SWIG_TypeClientData(SWIGTYPE_p_wxGIFAnimation, obj);
	3697	Py_INCREF(obj);
	3698	return Py_BuildValue((char *)"");
	3699	}
	3700	static PyObject _wrap_new_GIFAnimationCtrl(PyObject , PyObject args, PyObject kwargs) {
	3701	PyObject *resultobj;
	3702	wxWindow arg1 = (wxWindow ) 0 ;
	3703	int arg2 = (int) -1 ;
	3704	wxString const &arg3_defvalue = wxPyEmptyString ;
	3705	wxString arg3 = (wxString ) &arg3_defvalue ;
	3706	wxPoint const &arg4_defvalue = wxDefaultPosition ;
	3707	wxPoint arg4 = (wxPoint ) &arg4_defvalue ;
	3708	wxSize const &arg5_defvalue = wxDefaultSize ;
	3709	wxSize arg5 = (wxSize ) &arg5_defvalue ;
	3710	long arg6 = (long) wxAN_FIT_ANIMATION\|wxNO_BORDER ;
	3711	wxString const &arg7_defvalue = wxPyAnimationControlNameStr ;
	3712	wxString arg7 = (wxString ) &arg7_defvalue ;
	3713	wxGIFAnimationCtrl *result;
	3714	bool temp3 = false ;
	3715	wxPoint temp4 ;
	3716	wxSize temp5 ;
	3717	bool temp7 = false ;
	3718	PyObject * obj0 = 0 ;
	3719	PyObject * obj1 = 0 ;
	3720	PyObject * obj2 = 0 ;
	3721	PyObject * obj3 = 0 ;
	3722	PyObject * obj4 = 0 ;
	3723	PyObject * obj5 = 0 ;
	3724	PyObject * obj6 = 0 ;
	3725	char *kwnames[] = {
	3726	(char ) "parent",(char ) "id",(char ) "filename",(char ) "pos",(char ) "size",(char ) "style",(char *) "name", NULL
	3727	};
	3728
	3729	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|OOOOOO:new_GIFAnimationCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
	3730	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	3731	if (SWIG_arg_fail(1)) SWIG_fail;
	3732	if (obj1) {
	3733	{
	3734	arg2 = (int)(SWIG_As_int(obj1));
	3735	if (SWIG_arg_fail(2)) SWIG_fail;
	3736	}
	3737	}
	3738	if (obj2) {
	3739	{
	3740	arg3 = wxString_in_helper(obj2);
	3741	if (arg3 == NULL) SWIG_fail;
	3742	temp3 = true;
	3743	}
	3744	}
	3745	if (obj3) {
	3746	{
	3747	arg4 = &temp4;
	3748	if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
	3749	}
	3750	}
	3751	if (obj4) {
	3752	{
	3753	arg5 = &temp5;
	3754	if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
	3755	}
	3756	}
	3757	if (obj5) {
	3758	{
	3759	arg6 = (long)(SWIG_As_long(obj5));
	3760	if (SWIG_arg_fail(6)) SWIG_fail;
	3761	}
	3762	}
	3763	if (obj6) {
	3764	{
	3765	arg7 = wxString_in_helper(obj6);
	3766	if (arg7 == NULL) SWIG_fail;
	3767	temp7 = true;
	3768	}
	3769	}
	3770	{
	3771	if (!wxPyCheckForApp()) SWIG_fail;
	3772	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3773	result = (wxGIFAnimationCtrl )new wxGIFAnimationCtrl(arg1,arg2,(wxString const &)arg3,(wxPoint const &)arg4,(wxSize const &)arg5,arg6,(wxString const &)*arg7);
	3774
	3775	wxPyEndAllowThreads(__tstate);
	3776	if (PyErr_Occurred()) SWIG_fail;
	3777	}
	3778	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFAnimationCtrl, 1);
	3779	{
	3780	if (temp3)
	3781	delete arg3;
	3782	}
	3783	{
	3784	if (temp7)
	3785	delete arg7;
	3786	}
	3787	return resultobj;
	3788	fail:
	3789	{
	3790	if (temp3)
	3791	delete arg3;
	3792	}
	3793	{
	3794	if (temp7)
	3795	delete arg7;
	3796	}
	3797	return NULL;
	3798	}
	3799
	3800
	3801	static PyObject _wrap_new_PreGIFAnimationCtrl(PyObject , PyObject args, PyObject kwargs) {
	3802	PyObject *resultobj;
	3803	wxGIFAnimationCtrl *result;
	3804	char *kwnames[] = {
	3805	NULL
	3806	};
	3807
	3808	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGIFAnimationCtrl",kwnames)) goto fail;
	3809	{
	3810	if (!wxPyCheckForApp()) SWIG_fail;
	3811	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3812	result = (wxGIFAnimationCtrl *)new wxGIFAnimationCtrl();
	3813
	3814	wxPyEndAllowThreads(__tstate);
	3815	if (PyErr_Occurred()) SWIG_fail;
	3816	}
	3817	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFAnimationCtrl, 1);
	3818	return resultobj;
	3819	fail:
	3820	return NULL;
	3821	}
	3822
	3823
	3824	static PyObject _wrap_GIFAnimationCtrl_Create(PyObject , PyObject args, PyObject kwargs) {
	3825	PyObject *resultobj;
	3826	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	3827	wxWindow arg2 = (wxWindow ) 0 ;
	3828	int arg3 = (int) -1 ;
	3829	wxString const &arg4_defvalue = wxPyEmptyString ;
	3830	wxString arg4 = (wxString ) &arg4_defvalue ;
	3831	wxPoint const &arg5_defvalue = wxDefaultPosition ;
	3832	wxPoint arg5 = (wxPoint ) &arg5_defvalue ;
	3833	wxSize const &arg6_defvalue = wxDefaultSize ;
	3834	wxSize arg6 = (wxSize ) &arg6_defvalue ;
	3835	long arg7 = (long) wxAN_FIT_ANIMATION\|wxNO_BORDER ;
	3836	wxString const &arg8_defvalue = wxPyAnimationControlNameStr ;
	3837	wxString arg8 = (wxString ) &arg8_defvalue ;
	3838	bool result;
	3839	bool temp4 = false ;
	3840	wxPoint temp5 ;
	3841	wxSize temp6 ;
	3842	bool temp8 = false ;
	3843	PyObject * obj0 = 0 ;
	3844	PyObject * obj1 = 0 ;
	3845	PyObject * obj2 = 0 ;
	3846	PyObject * obj3 = 0 ;
	3847	PyObject * obj4 = 0 ;
	3848	PyObject * obj5 = 0 ;
	3849	PyObject * obj6 = 0 ;
	3850	PyObject * obj7 = 0 ;
	3851	char *kwnames[] = {
	3852	(char ) "self",(char ) "parent",(char ) "id",(char ) "filename",(char ) "pos",(char ) "size",(char ) "style",(char ) "name", NULL
	3853	};
	3854
	3855	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO\|OOOOOO:GIFAnimationCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
	3856	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	3857	if (SWIG_arg_fail(1)) SWIG_fail;
	3858	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	3859	if (SWIG_arg_fail(2)) SWIG_fail;
	3860	if (obj2) {
	3861	{
	3862	arg3 = (int)(SWIG_As_int(obj2));
	3863	if (SWIG_arg_fail(3)) SWIG_fail;
	3864	}
	3865	}
	3866	if (obj3) {
	3867	{
	3868	arg4 = wxString_in_helper(obj3);
	3869	if (arg4 == NULL) SWIG_fail;
	3870	temp4 = true;
	3871	}
	3872	}
	3873	if (obj4) {
	3874	{
	3875	arg5 = &temp5;
	3876	if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
	3877	}
	3878	}
	3879	if (obj5) {
	3880	{
	3881	arg6 = &temp6;
	3882	if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
	3883	}
	3884	}
	3885	if (obj6) {
	3886	{
	3887	arg7 = (long)(SWIG_As_long(obj6));
	3888	if (SWIG_arg_fail(7)) SWIG_fail;
	3889	}
	3890	}
	3891	if (obj7) {
	3892	{
	3893	arg8 = wxString_in_helper(obj7);
	3894	if (arg8 == NULL) SWIG_fail;
	3895	temp8 = true;
	3896	}
	3897	}
	3898	{
	3899	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3900	result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)arg4,(wxPoint const &)arg5,(wxSize const &)arg6,arg7,(wxString const &)arg8);
	3901
	3902	wxPyEndAllowThreads(__tstate);
	3903	if (PyErr_Occurred()) SWIG_fail;
	3904	}
	3905	{
	3906	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3907	}
	3908	{
	3909	if (temp4)
	3910	delete arg4;
	3911	}
	3912	{
	3913	if (temp8)
	3914	delete arg8;
	3915	}
	3916	return resultobj;
	3917	fail:
	3918	{
	3919	if (temp4)
	3920	delete arg4;
	3921	}
	3922	{
	3923	if (temp8)
	3924	delete arg8;
	3925	}
	3926	return NULL;
	3927	}
	3928
	3929
	3930	static PyObject _wrap_GIFAnimationCtrl_LoadFile(PyObject , PyObject args, PyObject kwargs) {
	3931	PyObject *resultobj;
	3932	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	3933	wxString const &arg2_defvalue = wxPyEmptyString ;
	3934	wxString arg2 = (wxString ) &arg2_defvalue ;
	3935	bool result;
	3936	bool temp2 = false ;
	3937	PyObject * obj0 = 0 ;
	3938	PyObject * obj1 = 0 ;
	3939	char *kwnames[] = {
	3940	(char ) "self",(char ) "filename", NULL
	3941	};
	3942
	3943	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|O:GIFAnimationCtrl_LoadFile",kwnames,&obj0,&obj1)) goto fail;
	3944	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	3945	if (SWIG_arg_fail(1)) SWIG_fail;
	3946	if (obj1) {
	3947	{
	3948	arg2 = wxString_in_helper(obj1);
	3949	if (arg2 == NULL) SWIG_fail;
	3950	temp2 = true;
	3951	}
	3952	}
	3953	{
	3954	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3955	result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
	3956
	3957	wxPyEndAllowThreads(__tstate);
	3958	if (PyErr_Occurred()) SWIG_fail;
	3959	}
	3960	{
	3961	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3962	}
	3963	{
	3964	if (temp2)
	3965	delete arg2;
	3966	}
	3967	return resultobj;
	3968	fail:
	3969	{
	3970	if (temp2)
	3971	delete arg2;
	3972	}
	3973	return NULL;
	3974	}
	3975
	3976
	3977	static PyObject _wrap_GIFAnimationCtrl_Play(PyObject , PyObject args, PyObject kwargs) {
	3978	PyObject *resultobj;
	3979	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	3980	bool arg2 = (bool) true ;
	3981	bool result;
	3982	PyObject * obj0 = 0 ;
	3983	PyObject * obj1 = 0 ;
	3984	char *kwnames[] = {
	3985	(char ) "self",(char ) "looped", NULL
	3986	};
	3987
	3988	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|O:GIFAnimationCtrl_Play",kwnames,&obj0,&obj1)) goto fail;
	3989	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	3990	if (SWIG_arg_fail(1)) SWIG_fail;
	3991	if (obj1) {
	3992	{
	3993	arg2 = (bool)(SWIG_As_bool(obj1));
	3994	if (SWIG_arg_fail(2)) SWIG_fail;
	3995	}
	3996	}
	3997	{
	3998	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3999	result = (bool)(arg1)->Play(arg2);
	4000
	4001	wxPyEndAllowThreads(__tstate);
	4002	if (PyErr_Occurred()) SWIG_fail;
	4003	}
	4004	{
	4005	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	4006	}
	4007	return resultobj;
	4008	fail:
	4009	return NULL;
	4010	}
	4011
	4012
	4013	static PyObject _wrap_GIFAnimationCtrl_Stop(PyObject , PyObject args, PyObject kwargs) {
	4014	PyObject *resultobj;
	4015	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4016	PyObject * obj0 = 0 ;
	4017	char *kwnames[] = {
	4018	(char *) "self", NULL
	4019	};
	4020
	4021	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_Stop",kwnames,&obj0)) goto fail;
	4022	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4023	if (SWIG_arg_fail(1)) SWIG_fail;
	4024	{
	4025	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4026	(arg1)->Stop();
	4027
	4028	wxPyEndAllowThreads(__tstate);
	4029	if (PyErr_Occurred()) SWIG_fail;
	4030	}
	4031	Py_INCREF(Py_None); resultobj = Py_None;
	4032	return resultobj;
	4033	fail:
	4034	return NULL;
	4035	}
	4036
	4037
	4038	static PyObject _wrap_GIFAnimationCtrl_FitToAnimation(PyObject , PyObject args, PyObject kwargs) {
	4039	PyObject *resultobj;
	4040	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4041	PyObject * obj0 = 0 ;
	4042	char *kwnames[] = {
	4043	(char *) "self", NULL
	4044	};
	4045
	4046	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_FitToAnimation",kwnames,&obj0)) goto fail;
	4047	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4048	if (SWIG_arg_fail(1)) SWIG_fail;
	4049	{
	4050	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4051	(arg1)->FitToAnimation();
	4052
	4053	wxPyEndAllowThreads(__tstate);
	4054	if (PyErr_Occurred()) SWIG_fail;
	4055	}
	4056	Py_INCREF(Py_None); resultobj = Py_None;
	4057	return resultobj;
	4058	fail:
	4059	return NULL;
	4060	}
	4061
	4062
	4063	static PyObject _wrap_GIFAnimationCtrl_IsPlaying(PyObject , PyObject args, PyObject kwargs) {
	4064	PyObject *resultobj;
	4065	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4066	bool result;
	4067	PyObject * obj0 = 0 ;
	4068	char *kwnames[] = {
	4069	(char *) "self", NULL
	4070	};
	4071
	4072	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_IsPlaying",kwnames,&obj0)) goto fail;
	4073	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4074	if (SWIG_arg_fail(1)) SWIG_fail;
	4075	{
	4076	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4077	result = (bool)((wxGIFAnimationCtrl const *)arg1)->IsPlaying();
	4078
	4079	wxPyEndAllowThreads(__tstate);
	4080	if (PyErr_Occurred()) SWIG_fail;
	4081	}
	4082	{
	4083	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	4084	}
	4085	return resultobj;
	4086	fail:
	4087	return NULL;
	4088	}
	4089
	4090
	4091	static PyObject _wrap_GIFAnimationCtrl_GetPlayer(PyObject , PyObject args, PyObject kwargs) {
	4092	PyObject *resultobj;
	4093	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4094	wxAnimationPlayer *result;
	4095	PyObject * obj0 = 0 ;
	4096	char *kwnames[] = {
	4097	(char *) "self", NULL
	4098	};
	4099
	4100	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_GetPlayer",kwnames,&obj0)) goto fail;
	4101	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4102	if (SWIG_arg_fail(1)) SWIG_fail;
	4103	{
	4104	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4105	{
	4106	wxAnimationPlayer &_result_ref = (arg1)->GetPlayer();
	4107	result = (wxAnimationPlayer *) &_result_ref;
	4108	}
	4109
	4110	wxPyEndAllowThreads(__tstate);
	4111	if (PyErr_Occurred()) SWIG_fail;
	4112	}
	4113	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAnimationPlayer, 0);
	4114	return resultobj;
	4115	fail:
	4116	return NULL;
	4117	}
	4118
	4119
	4120	static PyObject _wrap_GIFAnimationCtrl_GetAnimation(PyObject , PyObject args, PyObject kwargs) {
	4121	PyObject *resultobj;
	4122	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4123	wxAnimationBase *result;
	4124	PyObject * obj0 = 0 ;
	4125	char *kwnames[] = {
	4126	(char *) "self", NULL
	4127	};
	4128
	4129	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_GetAnimation",kwnames,&obj0)) goto fail;
	4130	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4131	if (SWIG_arg_fail(1)) SWIG_fail;
	4132	{
	4133	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4134	result = (wxAnimationBase *)(arg1)->GetAnimation();
	4135
	4136	wxPyEndAllowThreads(__tstate);
	4137	if (PyErr_Occurred()) SWIG_fail;
	4138	}
	4139	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAnimationBase, 0);
	4140	return resultobj;
	4141	fail:
	4142	return NULL;
	4143	}
	4144
	4145
	4146	static PyObject _wrap_GIFAnimationCtrl_GetFilename(PyObject , PyObject args, PyObject kwargs) {
	4147	PyObject *resultobj;
	4148	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4149	wxString *result;
	4150	PyObject * obj0 = 0 ;
	4151	char *kwnames[] = {
	4152	(char *) "self", NULL
	4153	};
	4154
	4155	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_GetFilename",kwnames,&obj0)) goto fail;
	4156	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4157	if (SWIG_arg_fail(1)) SWIG_fail;
	4158	{
	4159	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4160	{
	4161	wxString const &_result_ref = ((wxGIFAnimationCtrl const *)arg1)->GetFilename();
	4162	result = (wxString *) &_result_ref;
	4163	}
	4164
	4165	wxPyEndAllowThreads(__tstate);
	4166	if (PyErr_Occurred()) SWIG_fail;
	4167	}
	4168	{
	4169	#if wxUSE_UNICODE
	4170	resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
	4171	#else
	4172	resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
	4173	#endif
	4174	}
	4175	return resultobj;
	4176	fail:
	4177	return NULL;
	4178	}
	4179
	4180
	4181	static PyObject _wrap_GIFAnimationCtrl_SetFilename(PyObject , PyObject args, PyObject kwargs) {
	4182	PyObject *resultobj;
	4183	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4184	wxString *arg2 = 0 ;
	4185	bool temp2 = false ;
	4186	PyObject * obj0 = 0 ;
	4187	PyObject * obj1 = 0 ;
	4188	char *kwnames[] = {
	4189	(char ) "self",(char ) "filename", NULL
	4190	};
	4191
	4192	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimationCtrl_SetFilename",kwnames,&obj0,&obj1)) goto fail;
	4193	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4194	if (SWIG_arg_fail(1)) SWIG_fail;
	4195	{
	4196	arg2 = wxString_in_helper(obj1);
	4197	if (arg2 == NULL) SWIG_fail;
	4198	temp2 = true;
	4199	}
	4200	{
	4201	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4202	(arg1)->SetFilename((wxString const &)*arg2);
	4203
	4204	wxPyEndAllowThreads(__tstate);
	4205	if (PyErr_Occurred()) SWIG_fail;
	4206	}
	4207	Py_INCREF(Py_None); resultobj = Py_None;
	4208	{
	4209	if (temp2)
	4210	delete arg2;
	4211	}
	4212	return resultobj;
	4213	fail:
	4214	{
	4215	if (temp2)
	4216	delete arg2;
	4217	}
	4218	return NULL;
	4219	}
	4220
	4221
	4222	static PyObject * GIFAnimationCtrl_swigregister(PyObject , PyObject args) {
	4223	PyObject *obj;
	4224	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	4225	SWIG_TypeClientData(SWIGTYPE_p_wxGIFAnimationCtrl, obj);
	4226	Py_INCREF(obj);
	4227	return Py_BuildValue((char *)"");
	4228	}
	4229	static PyMethodDef SwigMethods[] = {
	4230	{ (char *)"new_AnimationPlayer", (PyCFunction) _wrap_new_AnimationPlayer, METH_VARARGS \| METH_KEYWORDS, NULL},
	4231	{ (char *)"delete_AnimationPlayer", (PyCFunction) _wrap_delete_AnimationPlayer, METH_VARARGS \| METH_KEYWORDS, NULL},
	4232	{ (char *)"AnimationPlayer_SetAnimation", (PyCFunction) _wrap_AnimationPlayer_SetAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4233	{ (char *)"AnimationPlayer_GetAnimation", (PyCFunction) _wrap_AnimationPlayer_GetAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4234	{ (char *)"AnimationPlayer_SetDestroyAnimation", (PyCFunction) _wrap_AnimationPlayer_SetDestroyAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4235	{ (char *)"AnimationPlayer_GetDestroyAnimation", (PyCFunction) _wrap_AnimationPlayer_GetDestroyAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4236	{ (char *)"AnimationPlayer_SetCurrentFrame", (PyCFunction) _wrap_AnimationPlayer_SetCurrentFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4237	{ (char *)"AnimationPlayer_GetCurrentFrame", (PyCFunction) _wrap_AnimationPlayer_GetCurrentFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4238	{ (char *)"AnimationPlayer_SetWindow", (PyCFunction) _wrap_AnimationPlayer_SetWindow, METH_VARARGS \| METH_KEYWORDS, NULL},
	4239	{ (char *)"AnimationPlayer_GetWindow", (PyCFunction) _wrap_AnimationPlayer_GetWindow, METH_VARARGS \| METH_KEYWORDS, NULL},
	4240	{ (char *)"AnimationPlayer_SetPosition", (PyCFunction) _wrap_AnimationPlayer_SetPosition, METH_VARARGS \| METH_KEYWORDS, NULL},
	4241	{ (char *)"AnimationPlayer_GetPosition", (PyCFunction) _wrap_AnimationPlayer_GetPosition, METH_VARARGS \| METH_KEYWORDS, NULL},
	4242	{ (char *)"AnimationPlayer_SetLooped", (PyCFunction) _wrap_AnimationPlayer_SetLooped, METH_VARARGS \| METH_KEYWORDS, NULL},
	4243	{ (char *)"AnimationPlayer_GetLooped", (PyCFunction) _wrap_AnimationPlayer_GetLooped, METH_VARARGS \| METH_KEYWORDS, NULL},
	4244	{ (char *)"AnimationPlayer_HasAnimation", (PyCFunction) _wrap_AnimationPlayer_HasAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4245	{ (char *)"AnimationPlayer_IsPlaying", (PyCFunction) _wrap_AnimationPlayer_IsPlaying, METH_VARARGS \| METH_KEYWORDS, NULL},
	4246	{ (char *)"AnimationPlayer_UseBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_UseBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4247	{ (char *)"AnimationPlayer_UsingBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_UsingBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4248	{ (char *)"AnimationPlayer_SetCustomBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_SetCustomBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4249	{ (char *)"AnimationPlayer_UsingCustomBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_UsingCustomBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4250	{ (char *)"AnimationPlayer_GetCustomBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_GetCustomBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4251	{ (char *)"AnimationPlayer_UseParentBackground", (PyCFunction) _wrap_AnimationPlayer_UseParentBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4252	{ (char *)"AnimationPlayer_UsingParentBackground", (PyCFunction) _wrap_AnimationPlayer_UsingParentBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4253	{ (char *)"AnimationPlayer_Play", (PyCFunction) _wrap_AnimationPlayer_Play, METH_VARARGS \| METH_KEYWORDS, NULL},
	4254	{ (char *)"AnimationPlayer_Build", (PyCFunction) _wrap_AnimationPlayer_Build, METH_VARARGS \| METH_KEYWORDS, NULL},
	4255	{ (char *)"AnimationPlayer_Stop", (PyCFunction) _wrap_AnimationPlayer_Stop, METH_VARARGS \| METH_KEYWORDS, NULL},
	4256	{ (char *)"AnimationPlayer_Draw", (PyCFunction) _wrap_AnimationPlayer_Draw, METH_VARARGS \| METH_KEYWORDS, NULL},
	4257	{ (char *)"AnimationPlayer_GetFrameCount", (PyCFunction) _wrap_AnimationPlayer_GetFrameCount, METH_VARARGS \| METH_KEYWORDS, NULL},
	4258	{ (char *)"AnimationPlayer_GetFrame", (PyCFunction) _wrap_AnimationPlayer_GetFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4259	{ (char *)"AnimationPlayer_GetDisposalMethod", (PyCFunction) _wrap_AnimationPlayer_GetDisposalMethod, METH_VARARGS \| METH_KEYWORDS, NULL},
	4260	{ (char *)"AnimationPlayer_GetFrameRect", (PyCFunction) _wrap_AnimationPlayer_GetFrameRect, METH_VARARGS \| METH_KEYWORDS, NULL},
	4261	{ (char *)"AnimationPlayer_GetDelay", (PyCFunction) _wrap_AnimationPlayer_GetDelay, METH_VARARGS \| METH_KEYWORDS, NULL},
	4262	{ (char *)"AnimationPlayer_GetLogicalScreenSize", (PyCFunction) _wrap_AnimationPlayer_GetLogicalScreenSize, METH_VARARGS \| METH_KEYWORDS, NULL},
	4263	{ (char *)"AnimationPlayer_GetBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_GetBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4264	{ (char *)"AnimationPlayer_GetTransparentColour", (PyCFunction) _wrap_AnimationPlayer_GetTransparentColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4265	{ (char *)"AnimationPlayer_PlayFrame", (PyCFunction) _wrap_AnimationPlayer_PlayFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4266	{ (char *)"AnimationPlayer_PlayNextFrame", (PyCFunction) _wrap_AnimationPlayer_PlayNextFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4267	{ (char *)"AnimationPlayer_DrawFrame", (PyCFunction) _wrap_AnimationPlayer_DrawFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4268	{ (char *)"AnimationPlayer_DrawBackground", (PyCFunction) _wrap_AnimationPlayer_DrawBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4269	{ (char *)"AnimationPlayer_ClearCache", (PyCFunction) _wrap_AnimationPlayer_ClearCache, METH_VARARGS \| METH_KEYWORDS, NULL},
	4270	{ (char *)"AnimationPlayer_SaveBackground", (PyCFunction) _wrap_AnimationPlayer_SaveBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4271	{ (char *)"AnimationPlayer_GetBackingStore", (PyCFunction) _wrap_AnimationPlayer_GetBackingStore, METH_VARARGS \| METH_KEYWORDS, NULL},
	4272	{ (char *)"AnimationPlayer_swigregister", AnimationPlayer_swigregister, METH_VARARGS, NULL},
	4273	{ (char *)"delete_AnimationBase", (PyCFunction) _wrap_delete_AnimationBase, METH_VARARGS \| METH_KEYWORDS, NULL},
	4274	{ (char *)"AnimationBase_GetFrameCount", (PyCFunction) _wrap_AnimationBase_GetFrameCount, METH_VARARGS \| METH_KEYWORDS, NULL},
	4275	{ (char *)"AnimationBase_GetFrame", (PyCFunction) _wrap_AnimationBase_GetFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4276	{ (char *)"AnimationBase_GetDisposalMethod", (PyCFunction) _wrap_AnimationBase_GetDisposalMethod, METH_VARARGS \| METH_KEYWORDS, NULL},
	4277	{ (char *)"AnimationBase_GetFrameRect", (PyCFunction) _wrap_AnimationBase_GetFrameRect, METH_VARARGS \| METH_KEYWORDS, NULL},
	4278	{ (char *)"AnimationBase_GetDelay", (PyCFunction) _wrap_AnimationBase_GetDelay, METH_VARARGS \| METH_KEYWORDS, NULL},
	4279	{ (char *)"AnimationBase_GetLogicalScreenSize", (PyCFunction) _wrap_AnimationBase_GetLogicalScreenSize, METH_VARARGS \| METH_KEYWORDS, NULL},
	4280	{ (char *)"AnimationBase_GetBackgroundColour", (PyCFunction) _wrap_AnimationBase_GetBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4281	{ (char *)"AnimationBase_GetTransparentColour", (PyCFunction) _wrap_AnimationBase_GetTransparentColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4282	{ (char *)"AnimationBase_IsValid", (PyCFunction) _wrap_AnimationBase_IsValid, METH_VARARGS \| METH_KEYWORDS, NULL},
	4283	{ (char *)"AnimationBase_LoadFile", (PyCFunction) _wrap_AnimationBase_LoadFile, METH_VARARGS \| METH_KEYWORDS, NULL},
	4284	{ (char *)"AnimationBase_swigregister", AnimationBase_swigregister, METH_VARARGS, NULL},
	4285	{ (char *)"new_GIFAnimation", (PyCFunction) _wrap_new_GIFAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4286	{ (char *)"delete_GIFAnimation", (PyCFunction) _wrap_delete_GIFAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4287	{ (char *)"GIFAnimation_GetFrameCount", (PyCFunction) _wrap_GIFAnimation_GetFrameCount, METH_VARARGS \| METH_KEYWORDS, NULL},
	4288	{ (char *)"GIFAnimation_GetFrame", (PyCFunction) _wrap_GIFAnimation_GetFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4289	{ (char *)"GIFAnimation_GetDisposalMethod", (PyCFunction) _wrap_GIFAnimation_GetDisposalMethod, METH_VARARGS \| METH_KEYWORDS, NULL},
	4290	{ (char *)"GIFAnimation_GetFrameRect", (PyCFunction) _wrap_GIFAnimation_GetFrameRect, METH_VARARGS \| METH_KEYWORDS, NULL},
	4291	{ (char *)"GIFAnimation_GetDelay", (PyCFunction) _wrap_GIFAnimation_GetDelay, METH_VARARGS \| METH_KEYWORDS, NULL},
	4292	{ (char *)"GIFAnimation_GetLogicalScreenSize", (PyCFunction) _wrap_GIFAnimation_GetLogicalScreenSize, METH_VARARGS \| METH_KEYWORDS, NULL},
	4293	{ (char *)"GIFAnimation_GetBackgroundColour", (PyCFunction) _wrap_GIFAnimation_GetBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4294	{ (char *)"GIFAnimation_GetTransparentColour", (PyCFunction) _wrap_GIFAnimation_GetTransparentColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4295	{ (char *)"GIFAnimation_IsValid", (PyCFunction) _wrap_GIFAnimation_IsValid, METH_VARARGS \| METH_KEYWORDS, NULL},
	4296	{ (char *)"GIFAnimation_LoadFile", (PyCFunction) _wrap_GIFAnimation_LoadFile, METH_VARARGS \| METH_KEYWORDS, NULL},
	4297	{ (char *)"GIFAnimation_swigregister", GIFAnimation_swigregister, METH_VARARGS, NULL},
	4298	{ (char *)"new_GIFAnimationCtrl", (PyCFunction) _wrap_new_GIFAnimationCtrl, METH_VARARGS \| METH_KEYWORDS, NULL},
	4299	{ (char *)"new_PreGIFAnimationCtrl", (PyCFunction) _wrap_new_PreGIFAnimationCtrl, METH_VARARGS \| METH_KEYWORDS, NULL},
	4300	{ (char *)"GIFAnimationCtrl_Create", (PyCFunction) _wrap_GIFAnimationCtrl_Create, METH_VARARGS \| METH_KEYWORDS, NULL},
	4301	{ (char *)"GIFAnimationCtrl_LoadFile", (PyCFunction) _wrap_GIFAnimationCtrl_LoadFile, METH_VARARGS \| METH_KEYWORDS, NULL},
	4302	{ (char *)"GIFAnimationCtrl_Play", (PyCFunction) _wrap_GIFAnimationCtrl_Play, METH_VARARGS \| METH_KEYWORDS, NULL},
	4303	{ (char *)"GIFAnimationCtrl_Stop", (PyCFunction) _wrap_GIFAnimationCtrl_Stop, METH_VARARGS \| METH_KEYWORDS, NULL},
	4304	{ (char *)"GIFAnimationCtrl_FitToAnimation", (PyCFunction) _wrap_GIFAnimationCtrl_FitToAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4305	{ (char *)"GIFAnimationCtrl_IsPlaying", (PyCFunction) _wrap_GIFAnimationCtrl_IsPlaying, METH_VARARGS \| METH_KEYWORDS, NULL},
	4306	{ (char *)"GIFAnimationCtrl_GetPlayer", (PyCFunction) _wrap_GIFAnimationCtrl_GetPlayer, METH_VARARGS \| METH_KEYWORDS, NULL},
	4307	{ (char *)"GIFAnimationCtrl_GetAnimation", (PyCFunction) _wrap_GIFAnimationCtrl_GetAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4308	{ (char *)"GIFAnimationCtrl_GetFilename", (PyCFunction) _wrap_GIFAnimationCtrl_GetFilename, METH_VARARGS \| METH_KEYWORDS, NULL},
	4309	{ (char *)"GIFAnimationCtrl_SetFilename", (PyCFunction) _wrap_GIFAnimationCtrl_SetFilename, METH_VARARGS \| METH_KEYWORDS, NULL},
	4310	{ (char *)"GIFAnimationCtrl_swigregister", GIFAnimationCtrl_swigregister, METH_VARARGS, NULL},
	4311	{ NULL, NULL, 0, NULL }
	4312	};
	4313
	4314
	4315	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
	4316
	4317	static void _p_wxLayoutConstraintsTo_p_wxObject(void x) {
	4318	return (void )((wxObject ) ((wxLayoutConstraints *) x));
	4319	}
	4320	static void _p_wxGBSizerItemTo_p_wxObject(void x) {
	4321	return (void )((wxObject ) (wxSizerItem ) ((wxGBSizerItem ) x));
	4322	}
	4323	static void _p_wxSizerItemTo_p_wxObject(void x) {
	4324	return (void )((wxObject ) ((wxSizerItem *) x));
	4325	}
	4326	static void _p_wxScrollEventTo_p_wxObject(void x) {
	4327	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxScrollEvent *) x));
	4328	}
	4329	static void _p_wxIndividualLayoutConstraintTo_p_wxObject(void x) {
	4330	return (void )((wxObject ) ((wxIndividualLayoutConstraint *) x));
	4331	}
	4332	static void _p_wxStaticBoxSizerTo_p_wxObject(void x) {
	4333	return (void )((wxObject ) (wxSizer )(wxBoxSizer ) ((wxStaticBoxSizer *) x));
	4334	}
	4335	static void _p_wxBoxSizerTo_p_wxObject(void x) {
	4336	return (void )((wxObject ) (wxSizer ) ((wxBoxSizer ) x));
	4337	}
	4338	static void _p_wxSizerTo_p_wxObject(void x) {
	4339	return (void )((wxObject ) ((wxSizer *) x));
	4340	}
	4341	static void _p_wxGridBagSizerTo_p_wxObject(void x) {
	4342	return (void )((wxObject ) (wxSizer )(wxGridSizer )(wxFlexGridSizer ) ((wxGridBagSizer ) x));
	4343	}
	4344	static void _p_wxUpdateUIEventTo_p_wxObject(void x) {
	4345	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxUpdateUIEvent *) x));
	4346	}
	4347	static void _p_wxEventTo_p_wxObject(void x) {
	4348	return (void )((wxObject ) ((wxEvent *) x));
	4349	}
	4350	static void _p_wxFlexGridSizerTo_p_wxObject(void x) {
	4351	return (void )((wxObject ) (wxSizer )(wxGridSizer ) ((wxFlexGridSizer *) x));
	4352	}
	4353	static void _p_wxGridSizerTo_p_wxObject(void x) {
	4354	return (void )((wxObject ) (wxSizer ) ((wxGridSizer ) x));
	4355	}
	4356	static void _p_wxInitDialogEventTo_p_wxObject(void x) {
	4357	return (void )((wxObject ) (wxEvent ) ((wxInitDialogEvent ) x));
	4358	}
	4359	static void _p_wxAnimationBaseTo_p_wxObject(void x) {
	4360	return (void )((wxObject ) ((wxAnimationBase *) x));
	4361	}
	4362	static void _p_wxPaintEventTo_p_wxObject(void x) {
	4363	return (void )((wxObject ) (wxEvent ) ((wxPaintEvent ) x));
	4364	}
	4365	static void _p_wxNcPaintEventTo_p_wxObject(void x) {
	4366	return (void )((wxObject ) (wxEvent ) ((wxNcPaintEvent ) x));
	4367	}
	4368	static void _p_wxPaletteChangedEventTo_p_wxObject(void x) {
	4369	return (void )((wxObject ) (wxEvent ) ((wxPaletteChangedEvent ) x));
	4370	}
	4371	static void _p_wxDisplayChangedEventTo_p_wxObject(void x) {
	4372	return (void )((wxObject ) (wxEvent ) ((wxDisplayChangedEvent ) x));
	4373	}
	4374	static void _p_wxMouseCaptureChangedEventTo_p_wxObject(void x) {
	4375	return (void )((wxObject ) (wxEvent ) ((wxMouseCaptureChangedEvent ) x));
	4376	}
	4377	static void _p_wxSysColourChangedEventTo_p_wxObject(void x) {
	4378	return (void )((wxObject ) (wxEvent ) ((wxSysColourChangedEvent ) x));
	4379	}
	4380	static void _p_wxControlTo_p_wxObject(void x) {
	4381	return (void )((wxObject ) (wxEvtHandler )(wxWindow ) ((wxControl *) x));
	4382	}
	4383	static void _p_wxSetCursorEventTo_p_wxObject(void x) {
	4384	return (void )((wxObject ) (wxEvent ) ((wxSetCursorEvent ) x));
	4385	}
	4386	static void _p_wxFSFileTo_p_wxObject(void x) {
	4387	return (void )((wxObject ) ((wxFSFile *) x));
	4388	}
	4389	static void _p_wxPySizerTo_p_wxObject(void x) {
	4390	return (void )((wxObject ) (wxSizer ) ((wxPySizer ) x));
	4391	}
	4392	static void _p_wxPyEventTo_p_wxObject(void x) {
	4393	return (void )((wxObject ) (wxEvent ) ((wxPyEvent ) x));
	4394	}
	4395	static void _p_wxNotifyEventTo_p_wxObject(void x) {
	4396	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxNotifyEvent *) x));
	4397	}
	4398	static void _p_wxShowEventTo_p_wxObject(void x) {
	4399	return (void )((wxObject ) (wxEvent ) ((wxShowEvent ) x));
	4400	}
	4401	static void _p_wxAnimationPlayerTo_p_wxObject(void x) {
	4402	return (void )((wxObject ) ((wxAnimationPlayer *) x));
	4403	}
	4404	static void _p_wxMenuItemTo_p_wxObject(void x) {
	4405	return (void )((wxObject ) ((wxMenuItem *) x));
	4406	}
	4407	static void _p_wxDateEventTo_p_wxObject(void x) {
	4408	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxDateEvent *) x));
	4409	}
	4410	static void _p_wxIdleEventTo_p_wxObject(void x) {
	4411	return (void )((wxObject ) (wxEvent ) ((wxIdleEvent ) x));
	4412	}
	4413	static void _p_wxWindowCreateEventTo_p_wxObject(void x) {
	4414	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxWindowCreateEvent *) x));
	4415	}
	4416	static void _p_wxQueryNewPaletteEventTo_p_wxObject(void x) {
	4417	return (void )((wxObject ) (wxEvent ) ((wxQueryNewPaletteEvent ) x));
	4418	}
	4419	static void _p_wxMaximizeEventTo_p_wxObject(void x) {
	4420	return (void )((wxObject ) (wxEvent ) ((wxMaximizeEvent ) x));
	4421	}
	4422	static void _p_wxIconizeEventTo_p_wxObject(void x) {
	4423	return (void )((wxObject ) (wxEvent ) ((wxIconizeEvent ) x));
	4424	}
	4425	static void _p_wxSizeEventTo_p_wxObject(void x) {
	4426	return (void )((wxObject ) (wxEvent ) ((wxSizeEvent ) x));
	4427	}
	4428	static void _p_wxMoveEventTo_p_wxObject(void x) {
	4429	return (void )((wxObject ) (wxEvent ) ((wxMoveEvent ) x));
	4430	}
	4431	static void _p_wxActivateEventTo_p_wxObject(void x) {
	4432	return (void )((wxObject ) (wxEvent ) ((wxActivateEvent ) x));
	4433	}
	4434	static void _p_wxXPMHandlerTo_p_wxObject(void x) {
	4435	return (void )((wxObject ) (wxImageHandler ) ((wxXPMHandler ) x));
	4436	}
	4437	static void _p_wxPNMHandlerTo_p_wxObject(void x) {
	4438	return (void )((wxObject ) (wxImageHandler ) ((wxPNMHandler ) x));
	4439	}
	4440	static void _p_wxJPEGHandlerTo_p_wxObject(void x) {
	4441	return (void )((wxObject ) (wxImageHandler ) ((wxJPEGHandler ) x));
	4442	}
	4443	static void _p_wxPCXHandlerTo_p_wxObject(void x) {
	4444	return (void )((wxObject ) (wxImageHandler ) ((wxPCXHandler ) x));
	4445	}
	4446	static void _p_wxGIFHandlerTo_p_wxObject(void x) {
	4447	return (void )((wxObject ) (wxImageHandler ) ((wxGIFHandler ) x));
	4448	}
	4449	static void _p_wxPNGHandlerTo_p_wxObject(void x) {
	4450	return (void )((wxObject ) (wxImageHandler ) ((wxPNGHandler ) x));
	4451	}
	4452	static void _p_wxANIHandlerTo_p_wxObject(void x) {
	4453	return (void )((wxObject ) (wxImageHandler )(wxBMPHandler )(wxICOHandler )(wxCURHandler ) ((wxANIHandler *) x));
	4454	}
	4455	static void _p_wxCURHandlerTo_p_wxObject(void x) {
	4456	return (void )((wxObject ) (wxImageHandler )(wxBMPHandler )(wxICOHandler ) ((wxCURHandler ) x));
	4457	}
	4458	static void _p_wxICOHandlerTo_p_wxObject(void x) {
	4459	return (void )((wxObject ) (wxImageHandler )(wxBMPHandler ) ((wxICOHandler *) x));
	4460	}
	4461	static void _p_wxBMPHandlerTo_p_wxObject(void x) {
	4462	return (void )((wxObject ) (wxImageHandler ) ((wxBMPHandler ) x));
	4463	}
	4464	static void _p_wxImageHandlerTo_p_wxObject(void x) {
	4465	return (void )((wxObject ) ((wxImageHandler *) x));
	4466	}
	4467	static void _p_wxTIFFHandlerTo_p_wxObject(void x) {
	4468	return (void )((wxObject ) (wxImageHandler ) ((wxTIFFHandler ) x));
	4469	}
	4470	static void _p_wxEvtHandlerTo_p_wxObject(void x) {
	4471	return (void )((wxObject ) ((wxEvtHandler *) x));
	4472	}
	4473	static void _p_wxStdDialogButtonSizerTo_p_wxObject(void x) {
	4474	return (void )((wxObject ) (wxSizer )(wxBoxSizer ) ((wxStdDialogButtonSizer *) x));
	4475	}
	4476	static void _p_wxAcceleratorTableTo_p_wxObject(void x) {
	4477	return (void )((wxObject ) ((wxAcceleratorTable *) x));
	4478	}
	4479	static void _p_wxImageTo_p_wxObject(void x) {
	4480	return (void )((wxObject ) ((wxImage *) x));
	4481	}
	4482	static void _p_wxScrollWinEventTo_p_wxObject(void x) {
	4483	return (void )((wxObject ) (wxEvent ) ((wxScrollWinEvent ) x));
	4484	}
	4485	static void _p_wxWindowDestroyEventTo_p_wxObject(void x) {
	4486	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxWindowDestroyEvent *) x));
	4487	}
	4488	static void _p_wxNavigationKeyEventTo_p_wxObject(void x) {
	4489	return (void )((wxObject ) (wxEvent ) ((wxNavigationKeyEvent ) x));
	4490	}
	4491	static void _p_wxKeyEventTo_p_wxObject(void x) {
	4492	return (void )((wxObject ) (wxEvent ) ((wxKeyEvent ) x));
	4493	}
	4494	static void _p_wxWindowTo_p_wxObject(void x) {
	4495	return (void )((wxObject ) (wxEvtHandler ) ((wxWindow ) x));
	4496	}
	4497	static void _p_wxMenuTo_p_wxObject(void x) {
	4498	return (void )((wxObject ) (wxEvtHandler ) ((wxMenu ) x));
	4499	}
	4500	static void _p_wxMenuBarTo_p_wxObject(void x) {
	4501	return (void )((wxObject ) (wxEvtHandler )(wxWindow ) ((wxMenuBar *) x));
	4502	}
	4503	static void _p_wxFileSystemTo_p_wxObject(void x) {
	4504	return (void )((wxObject ) ((wxFileSystem *) x));
	4505	}
	4506	static void _p_wxGIFAnimationTo_p_wxObject(void x) {
	4507	return (void )((wxObject ) (wxAnimationBase ) ((wxGIFAnimation ) x));
	4508	}
	4509	static void _p_wxContextMenuEventTo_p_wxObject(void x) {
	4510	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxContextMenuEvent *) x));
	4511	}
	4512	static void _p_wxMenuEventTo_p_wxObject(void x) {
	4513	return (void )((wxObject ) (wxEvent ) ((wxMenuEvent ) x));
	4514	}
	4515	static void _p_wxPyAppTo_p_wxObject(void x) {
	4516	return (void )((wxObject ) (wxEvtHandler ) ((wxPyApp ) x));
	4517	}
	4518	static void _p_wxCloseEventTo_p_wxObject(void x) {
	4519	return (void )((wxObject ) (wxEvent ) ((wxCloseEvent ) x));
	4520	}
	4521	static void _p_wxMouseEventTo_p_wxObject(void x) {
	4522	return (void )((wxObject ) (wxEvent ) ((wxMouseEvent ) x));
	4523	}
	4524	static void _p_wxEraseEventTo_p_wxObject(void x) {
	4525	return (void )((wxObject ) (wxEvent ) ((wxEraseEvent ) x));
	4526	}
	4527	static void _p_wxPyCommandEventTo_p_wxObject(void x) {
	4528	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxPyCommandEvent *) x));
	4529	}
	4530	static void _p_wxCommandEventTo_p_wxObject(void x) {
	4531	return (void )((wxObject ) (wxEvent ) ((wxCommandEvent ) x));
	4532	}
	4533	static void _p_wxDropFilesEventTo_p_wxObject(void x) {
	4534	return (void )((wxObject ) (wxEvent ) ((wxDropFilesEvent ) x));
	4535	}
	4536	static void _p_wxFocusEventTo_p_wxObject(void x) {
	4537	return (void )((wxObject ) (wxEvent ) ((wxFocusEvent ) x));
	4538	}
	4539	static void _p_wxChildFocusEventTo_p_wxObject(void x) {
	4540	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxChildFocusEvent *) x));
	4541	}
	4542	static void _p_wxGIFAnimationCtrlTo_p_wxObject(void x) {
	4543	return (void )((wxObject ) (wxEvtHandler )(wxWindow )(wxControl ) ((wxGIFAnimationCtrl ) x));
	4544	}
	4545	static void _p_wxControlWithItemsTo_p_wxObject(void x) {
	4546	return (void )((wxObject ) (wxEvtHandler )(wxWindow )(wxControl ) ((wxControlWithItems ) x));
	4547	}
	4548	static void _p_wxPyValidatorTo_p_wxObject(void x) {
	4549	return (void )((wxObject ) (wxEvtHandler )(wxValidator ) ((wxPyValidator *) x));
	4550	}
	4551	static void _p_wxValidatorTo_p_wxObject(void x) {
	4552	return (void )((wxObject ) (wxEvtHandler ) ((wxValidator ) x));
	4553	}
	4554	static void _p_wxControlTo_p_wxWindow(void x) {
	4555	return (void )((wxWindow ) ((wxControl *) x));
	4556	}
	4557	static void _p_wxControlWithItemsTo_p_wxWindow(void x) {
	4558	return (void )((wxWindow ) (wxControl ) ((wxControlWithItems ) x));
	4559	}
	4560	static void _p_wxGIFAnimationCtrlTo_p_wxWindow(void x) {
	4561	return (void )((wxWindow ) (wxControl ) ((wxGIFAnimationCtrl ) x));
	4562	}
	4563	static void _p_wxMenuBarTo_p_wxWindow(void x) {
	4564	return (void )((wxWindow ) ((wxMenuBar *) x));
	4565	}
	4566	static void _p_wxGIFAnimationTo_p_wxAnimationBase(void x) {
	4567	return (void )((wxAnimationBase ) ((wxGIFAnimation *) x));
	4568	}
	4569	static void _p_wxControlTo_p_wxEvtHandler(void x) {
	4570	return (void )((wxEvtHandler ) (wxWindow ) ((wxControl ) x));
	4571	}
	4572	static void _p_wxWindowTo_p_wxEvtHandler(void x) {
	4573	return (void )((wxEvtHandler ) ((wxWindow *) x));
	4574	}
	4575	static void _p_wxControlWithItemsTo_p_wxEvtHandler(void x) {
	4576	return (void )((wxEvtHandler ) (wxWindow )(wxControl ) ((wxControlWithItems *) x));
	4577	}
	4578	static void _p_wxPyAppTo_p_wxEvtHandler(void x) {
	4579	return (void )((wxEvtHandler ) ((wxPyApp *) x));
	4580	}
	4581	static void _p_wxGIFAnimationCtrlTo_p_wxEvtHandler(void x) {
	4582	return (void )((wxEvtHandler ) (wxWindow )(wxControl ) ((wxGIFAnimationCtrl *) x));
	4583	}
	4584	static void _p_wxValidatorTo_p_wxEvtHandler(void x) {
	4585	return (void )((wxEvtHandler ) ((wxValidator *) x));
	4586	}
	4587	static void _p_wxPyValidatorTo_p_wxEvtHandler(void x) {
	4588	return (void )((wxEvtHandler ) (wxValidator ) ((wxPyValidator ) x));
	4589	}
	4590	static void _p_wxMenuBarTo_p_wxEvtHandler(void x) {
	4591	return (void )((wxEvtHandler ) (wxWindow ) ((wxMenuBar ) x));
	4592	}
	4593	static void _p_wxMenuTo_p_wxEvtHandler(void x) {
	4594	return (void )((wxEvtHandler ) ((wxMenu *) x));
	4595	}
	4596	static void _p_wxControlWithItemsTo_p_wxControl(void x) {
	4597	return (void )((wxControl ) ((wxControlWithItems *) x));
	4598	}
	4599	static void _p_wxGIFAnimationCtrlTo_p_wxControl(void x) {
	4600	return (void )((wxControl ) ((wxGIFAnimationCtrl *) x));
	4601	}
	4602	static swig_type_info _swigt__p_wxRect[] = {{"_p_wxRect", 0, "wxRect *", 0, 0, 0, 0},{"_p_wxRect", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4603	static swig_type_info _swigt__p_wxGIFAnimationCtrl[] = {{"_p_wxGIFAnimationCtrl", 0, "wxGIFAnimationCtrl *", 0, 0, 0, 0},{"_p_wxGIFAnimationCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4604	static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAnimationBase", _p_wxAnimationBaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAnimationPlayer", _p_wxAnimationPlayerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFAnimation", _p_wxGIFAnimationTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFAnimationCtrl", _p_wxGIFAnimationCtrlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4605	static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char \|byte ", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4606	static swig_type_info _swigt__p_wxColour[] = {{"_p_wxColour", 0, "wxColour *", 0, 0, 0, 0},{"_p_wxColour", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4607	static swig_type_info _swigt__p_wxAnimationPlayer[] = {{"_p_wxAnimationPlayer", 0, "wxAnimationPlayer *", 0, 0, 0, 0},{"_p_wxAnimationPlayer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4608	static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxGIFAnimationCtrl", _p_wxGIFAnimationCtrlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4609	static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long \|wxUIntPtr ", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4610	static swig_type_info _swigt__p_wxBitmap[] = {{"_p_wxBitmap", 0, "wxBitmap *", 0, 0, 0, 0},{"_p_wxBitmap", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4611	static swig_type_info _swigt__p_form_ops_t[] = {{"_p_form_ops_t", 0, "enum form_ops_t \|form_ops_t ", 0, 0, 0, 0},{"_p_form_ops_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4612	static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int \|time_t ", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4613	static swig_type_info _swigt__unsigned_int[] = {{"_unsigned_int", 0, "unsigned int\|std::size_t", 0, 0, 0, 0},{"_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4614	static swig_type_info _swigt__p_wxDuplexMode[] = {{"_p_wxDuplexMode", 0, "enum wxDuplexMode \|wxDuplexMode ", 0, 0, 0, 0},{"_p_wxDuplexMode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4615	static swig_type_info _swigt__p_wxGIFAnimation[] = {{"_p_wxGIFAnimation", 0, "wxGIFAnimation *", 0, 0, 0, 0},{"_p_wxGIFAnimation", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4616	static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4617	static swig_type_info _swigt__p_wxAnimationBase[] = {{"_p_wxAnimationBase", 0, "wxAnimationBase *", 0, 0, 0, 0},{"_p_wxAnimationBase", 0, 0, 0, 0, 0, 0},{"_p_wxGIFAnimation", _p_wxGIFAnimationTo_p_wxAnimationBase, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4618	static swig_type_info _swigt__p_wxPoint[] = {{"_p_wxPoint", 0, "wxPoint *", 0, 0, 0, 0},{"_p_wxPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4619	static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4620	static swig_type_info _swigt__p_wxEvtHandler[] = {{"_p_wxEvtHandler", 0, "wxEvtHandler *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", 0, 0, 0, 0, 0, 0},{"_p_wxGIFAnimationCtrl", _p_wxGIFAnimationCtrlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4621	static swig_type_info _swigt__std__ptrdiff_t[] = {{"_std__ptrdiff_t", 0, "std::ptrdiff_t", 0, 0, 0, 0},{"_std__ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4622	static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4623	static swig_type_info _swigt__p_wxControl[] = {{"_p_wxControl", 0, "wxControl *", 0, 0, 0, 0},{"_p_wxControl", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxControl, 0, 0, 0, 0, 0},{"_p_wxGIFAnimationCtrl", _p_wxGIFAnimationCtrlTo_p_wxControl, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4624	static swig_type_info _swigt__p_wxPaperSize[] = {{"_p_wxPaperSize", 0, "enum wxPaperSize \|wxPaperSize ", 0, 0, 0, 0},{"_p_wxPaperSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4625	static swig_type_info _swigt__p_wxSize[] = {{"_p_wxSize", 0, "wxSize *", 0, 0, 0, 0},{"_p_wxSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4626	static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int \|wxEventType ", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4627
	4628	static swig_type_info *swig_types_initial[] = {
	4629	_swigt__p_wxRect,
	4630	_swigt__p_wxGIFAnimationCtrl,
	4631	_swigt__p_wxObject,
	4632	_swigt__p_unsigned_char,
	4633	_swigt__p_wxColour,
	4634	_swigt__p_wxAnimationPlayer,
	4635	_swigt__p_wxWindow,
	4636	_swigt__p_unsigned_long,
	4637	_swigt__p_wxBitmap,
	4638	_swigt__p_form_ops_t,
	4639	_swigt__p_unsigned_int,
	4640	_swigt__unsigned_int,
	4641	_swigt__p_wxDuplexMode,
	4642	_swigt__p_wxGIFAnimation,
	4643	_swigt__p_char,
	4644	_swigt__p_wxAnimationBase,
	4645	_swigt__p_wxPoint,
	4646	_swigt__p_wxDC,
	4647	_swigt__p_wxEvtHandler,
	4648	_swigt__std__ptrdiff_t,
	4649	_swigt__ptrdiff_t,
	4650	_swigt__p_wxControl,
	4651	_swigt__p_wxPaperSize,
	4652	_swigt__p_wxSize,
	4653	_swigt__p_int,
	4654	0
	4655	};
	4656
	4657
	4658	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
	4659
	4660	static swig_const_info swig_const_table[] = {
	4661	{0, 0, 0, 0.0, 0, 0}};
	4662
	4663	#ifdef __cplusplus
	4664	}
	4665	#endif
	4666
	4667
	4668	#ifdef __cplusplus
	4669	extern "C" {
	4670	#endif
	4671
	4672	/* Python-specific SWIG API */
	4673	#define SWIG_newvarlink() SWIG_Python_newvarlink()
	4674	#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
	4675	#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
	4676
	4677	/* -----------------------------------------------------------------------------
	4678	* global variable support code.
	4679	* ----------------------------------------------------------------------------- */
	4680
	4681	typedef struct swig_globalvar {
	4682	char name; / Name of global variable */
	4683	PyObject (get_attr)(); /* Return the current value */
	4684	int (set_attr)(PyObject ); /* Set the value */
	4685	struct swig_globalvar *next;
	4686	} swig_globalvar;
	4687
	4688	typedef struct swig_varlinkobject {
	4689	PyObject_HEAD
	4690	swig_globalvar *vars;
	4691	} swig_varlinkobject;
	4692
	4693	static PyObject *
	4694	swig_varlink_repr(swig_varlinkobject *v) {
	4695	v = v;
	4696	return PyString_FromString("<Swig global variables>");
	4697	}
	4698
	4699	static int
	4700	swig_varlink_print(swig_varlinkobject v, FILE fp, int flags) {
	4701	swig_globalvar *var;
	4702	flags = flags;
	4703	fprintf(fp,"Swig global variables { ");
	4704	for (var = v->vars; var; var=var->next) {
	4705	fprintf(fp,"%s", var->name);
	4706	if (var->next) fprintf(fp,", ");
	4707	}
	4708	fprintf(fp," }\n");
	4709	return 0;
	4710	}
	4711
	4712	static PyObject *
	4713	swig_varlink_getattr(swig_varlinkobject v, char n) {
	4714	swig_globalvar *var = v->vars;
	4715	while (var) {
	4716	if (strcmp(var->name,n) == 0) {
	4717	return (*var->get_attr)();
	4718	}
	4719	var = var->next;
	4720	}
	4721	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
	4722	return NULL;
	4723	}
	4724
	4725	static int
	4726	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
	4727	swig_globalvar *var = v->vars;
	4728	while (var) {
	4729	if (strcmp(var->name,n) == 0) {
	4730	return (*var->set_attr)(p);
	4731	}
	4732	var = var->next;
	4733	}
	4734	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
	4735	return 1;
	4736	}
	4737
	4738	static PyTypeObject varlinktype = {
	4739	PyObject_HEAD_INIT(0)
	4740	0, /* Number of items in variable part (ob_size) */
	4741	(char )"swigvarlink", / Type name (tp_name) */
	4742	sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
	4743	0, /* Itemsize (tp_itemsize) */
	4744	0, /* Deallocator (tp_dealloc) */
	4745	(printfunc) swig_varlink_print, /* Print (tp_print) */
	4746	(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
	4747	(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
	4748	0, /* tp_compare */
	4749	(reprfunc) swig_varlink_repr, /* tp_repr */
	4750	0, /* tp_as_number */
	4751	0, /* tp_as_sequence */
	4752	0, /* tp_as_mapping */
	4753	0, /* tp_hash */
	4754	0, /* tp_call */
	4755	0, /* tp_str */
	4756	0, /* tp_getattro */
	4757	0, /* tp_setattro */
	4758	0, /* tp_as_buffer */
	4759	0, /* tp_flags */
	4760	0, /* tp_doc */
	4761	#if PY_VERSION_HEX >= 0x02000000
	4762	0, /* tp_traverse */
	4763	0, /* tp_clear */
	4764	#endif
	4765	#if PY_VERSION_HEX >= 0x02010000
	4766	0, /* tp_richcompare */
	4767	0, /* tp_weaklistoffset */
	4768	#endif
	4769	#if PY_VERSION_HEX >= 0x02020000
	4770	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
	4771	#endif
	4772	#if PY_VERSION_HEX >= 0x02030000
	4773	0, /* tp_del */
	4774	#endif
	4775	#ifdef COUNT_ALLOCS
	4776	0,0,0,0 /* tp_alloc -> tp_next */
	4777	#endif
	4778	};
	4779
	4780	/* Create a variable linking object for use later */
	4781	static PyObject *
	4782	SWIG_Python_newvarlink(void) {
	4783	swig_varlinkobject *result = 0;
	4784	result = PyMem_NEW(swig_varlinkobject,1);
	4785	varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
	4786	result->ob_type = &varlinktype;
	4787	result->vars = 0;
	4788	result->ob_refcnt = 0;
	4789	Py_XINCREF((PyObject *) result);
	4790	return ((PyObject*) result);
	4791	}
	4792
	4793	static void
	4794	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
	4795	swig_varlinkobject *v;
	4796	swig_globalvar *gv;
	4797	v= (swig_varlinkobject *) p;
	4798	gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
	4799	gv->name = (char *) malloc(strlen(name)+1);
	4800	strcpy(gv->name,name);
	4801	gv->get_attr = get_attr;
	4802	gv->set_attr = set_attr;
	4803	gv->next = v->vars;
	4804	v->vars = gv;
	4805	}
	4806
	4807	/* -----------------------------------------------------------------------------
	4808	* constants/methods manipulation
	4809	* ----------------------------------------------------------------------------- */
	4810
	4811	/* Install Constants */
	4812	static void
	4813	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
	4814	PyObject *obj = 0;
	4815	size_t i;
	4816	for (i = 0; constants[i].type; i++) {
	4817	switch(constants[i].type) {
	4818	case SWIG_PY_INT:
	4819	obj = PyInt_FromLong(constants[i].lvalue);
	4820	break;
	4821	case SWIG_PY_FLOAT:
	4822	obj = PyFloat_FromDouble(constants[i].dvalue);
	4823	break;
	4824	case SWIG_PY_STRING:
	4825	if (constants[i].pvalue) {
	4826	obj = PyString_FromString((char *) constants[i].pvalue);
	4827	} else {
	4828	Py_INCREF(Py_None);
	4829	obj = Py_None;
	4830	}
	4831	break;
	4832	case SWIG_PY_POINTER:
	4833	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
	4834	break;
	4835	case SWIG_PY_BINARY:
	4836	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
	4837	break;
	4838	default:
	4839	obj = 0;
	4840	break;
	4841	}
	4842	if (obj) {
	4843	PyDict_SetItemString(d,constants[i].name,obj);
	4844	Py_DECREF(obj);
	4845	}
	4846	}
	4847	}
	4848
	4849	/* -----------------------------------------------------------------------------*/
	4850	/* Fix SwigMethods to carry the callback ptrs when needed */
	4851	/* -----------------------------------------------------------------------------*/
	4852
	4853	static void
	4854	SWIG_Python_FixMethods(PyMethodDef *methods,
	4855	swig_const_info *const_table,
	4856	swig_type_info **types,
	4857	swig_type_info **types_initial) {
	4858	size_t i;
	4859	for (i = 0; methods[i].ml_name; ++i) {
	4860	char *c = methods[i].ml_doc;
	4861	if (c && (c = strstr(c, "swig_ptr: "))) {
	4862	int j;
	4863	swig_const_info *ci = 0;
	4864	char *name = c + 10;
	4865	for (j = 0; const_table[j].type; j++) {
	4866	if (strncmp(const_table[j].name, name,
	4867	strlen(const_table[j].name)) == 0) {
	4868	ci = &(const_table[j]);
	4869	break;
	4870	}
	4871	}
	4872	if (ci) {
	4873	size_t shift = (ci->ptype) - types;
	4874	swig_type_info *ty = types_initial[shift];
	4875	size_t ldoc = (c - methods[i].ml_doc);
	4876	size_t lptr = strlen(ty->name)+2sizeof(void)+2;
	4877	char ndoc = (char)malloc(ldoc + lptr + 10);
	4878	char *buff = ndoc;
	4879	void ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void )(ci->lvalue);
	4880	strncpy(buff, methods[i].ml_doc, ldoc);
	4881	buff += ldoc;
	4882	strncpy(buff, "swig_ptr: ", 10);
	4883	buff += 10;
	4884	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
	4885	methods[i].ml_doc = ndoc;
	4886	}
	4887	}
	4888	}
	4889	}
	4890
	4891	/* -----------------------------------------------------------------------------*
	4892	* Initialize type list
	4893	* -----------------------------------------------------------------------------*/
	4894
	4895	#if PY_MAJOR_VERSION < 2
	4896	/* PyModule_AddObject function was introduced in Python 2.0. The following function
	4897	is copied out of Python/modsupport.c in python version 2.3.4 */
	4898	static int
	4899	PyModule_AddObject(PyObject m, char name, PyObject *o)
	4900	{
	4901	PyObject *dict;
	4902	if (!PyModule_Check(m)) {
	4903	PyErr_SetString(PyExc_TypeError,
	4904	"PyModule_AddObject() needs module as first arg");
	4905	return -1;
	4906	}
	4907	if (!o) {
	4908	PyErr_SetString(PyExc_TypeError,
	4909	"PyModule_AddObject() needs non-NULL value");
	4910	return -1;
	4911	}
	4912
	4913	dict = PyModule_GetDict(m);
	4914	if (dict == NULL) {
	4915	/* Internal error -- modules must have a dict! */
	4916	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
	4917	PyModule_GetName(m));
	4918	return -1;
	4919	}
	4920	if (PyDict_SetItemString(dict, name, o))
	4921	return -1;
	4922	Py_DECREF(o);
	4923	return 0;
	4924	}
	4925	#endif
	4926
	4927	static swig_type_info **
	4928	SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
	4929	static PyMethodDef swig_empty_runtime_method_table[] = {
	4930	{
	4931	NULL, NULL, 0, NULL
	4932	}
	4933	};/* Sentinel */
	4934
	4935	PyObject module = Py_InitModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION,
	4936	swig_empty_runtime_method_table);
	4937	PyObject pointer = PyCObject_FromVoidPtr((void ) type_list_handle, NULL);
	4938	if (pointer && module) {
	4939	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
	4940	}
	4941	return type_list_handle;
	4942	}
	4943
	4944	static swig_type_info **
	4945	SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
	4946	swig_type_info **type_pointer;
	4947
	4948	/* first check if module already created */
	4949	type_pointer = SWIG_Python_GetTypeListHandle();
	4950	if (type_pointer) {
	4951	return type_pointer;
	4952	} else {
	4953	/* create a new module and variable */
	4954	return SWIG_Python_SetTypeListHandle(type_list_handle);
	4955	}
	4956	}
	4957
	4958	#ifdef __cplusplus
	4959	}
	4960	#endif
	4961
	4962	/* -----------------------------------------------------------------------------*
	4963	* Partial Init method
	4964	* -----------------------------------------------------------------------------*/
	4965
	4966	#ifdef SWIG_LINK_RUNTIME
	4967	#ifdef __cplusplus
	4968	extern "C"
	4969	#endif
	4970	SWIGEXPORT(void ) SWIG_ReturnGlobalTypeList(void );
	4971	#endif
	4972
	4973	#ifdef __cplusplus
	4974	extern "C"
	4975	#endif
	4976	SWIGEXPORT(void) SWIG_init(void) {
	4977	static PyObject *SWIG_globals = 0;
	4978	static int typeinit = 0;
	4979	PyObject m, d;
	4980	int i;
	4981	if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
	4982
	4983	/* Fix SwigMethods to carry the callback ptrs when needed */
	4984	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
	4985
	4986	m = Py_InitModule((char *) SWIG_name, SwigMethods);
	4987	d = PyModule_GetDict(m);
	4988
	4989	if (!typeinit) {
	4990	#ifdef SWIG_LINK_RUNTIME
	4991	swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
	4992	#else
	4993	# ifndef SWIG_STATIC_RUNTIME
	4994	swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
	4995	# endif
	4996	#endif
	4997	for (i = 0; swig_types_initial[i]; i++) {
	4998	swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
	4999	}
	5000	typeinit = 1;
	5001	}
	5002	SWIG_InstallConstants(d,swig_const_table);
	5003
	5004	PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
	5005	SWIG_addvarlink(SWIG_globals,(char*)"AnimationControlNameStr",_wrap_AnimationControlNameStr_get, _wrap_AnimationControlNameStr_set);
	5006	{
	5007	PyDict_SetItemString(d,"ANIM_UNSPECIFIED", SWIG_From_int((int)(wxANIM_UNSPECIFIED)));
	5008	}
	5009	{
	5010	PyDict_SetItemString(d,"ANIM_DONOTREMOVE", SWIG_From_int((int)(wxANIM_DONOTREMOVE)));
	5011	}
	5012	{
	5013	PyDict_SetItemString(d,"ANIM_TOBACKGROUND", SWIG_From_int((int)(wxANIM_TOBACKGROUND)));
	5014	}
	5015	{
	5016	PyDict_SetItemString(d,"ANIM_TOPREVIOUS", SWIG_From_int((int)(wxANIM_TOPREVIOUS)));
	5017	}
	5018	{
	5019	PyDict_SetItemString(d,"AN_FIT_ANIMATION", SWIG_From_int((int)(wxAN_FIT_ANIMATION)));
	5020	}
	5021	}
	5022