git.saurik.com Git - wxWidgets.git/blame_incremental - wxPython/contrib/animate/msw/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	Py_DECREF(str);
	1041	return;
	1042	}
	1043	}
	1044	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
	1045	} else {
	1046	PyErr_Format(PyExc_TypeError, "unexpected type is received");
	1047	}
	1048	}
	1049
	1050	SWIGRUNTIMEINLINE void
	1051	SWIG_Python_NullRef(const char *type)
	1052	{
	1053	if (type) {
	1054	PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
	1055	} else {
	1056	PyErr_Format(PyExc_TypeError, "null reference was received");
	1057	}
	1058	}
	1059
	1060	SWIGRUNTIME int
	1061	SWIG_Python_AddErrMesg(const char* mesg, int infront)
	1062	{
	1063	if (PyErr_Occurred()) {
	1064	PyObject *type = 0;
	1065	PyObject *value = 0;
	1066	PyObject *traceback = 0;
	1067	PyErr_Fetch(&type, &value, &traceback);
	1068	if (value) {
	1069	PyObject *old_str = PyObject_Str(value);
	1070	Py_XINCREF(type);
	1071	PyErr_Clear();
	1072	if (infront) {
	1073	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
	1074	} else {
	1075	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
	1076	}
	1077	Py_DECREF(old_str);
	1078	}
	1079	return 1;
	1080	} else {
	1081	return 0;
	1082	}
	1083	}
	1084
	1085	SWIGRUNTIME int
	1086	SWIG_Python_ArgFail(int argnum)
	1087	{
	1088	if (PyErr_Occurred()) {
	1089	/* add information about failing argument */
	1090	char mesg[256];
	1091	sprintf(mesg, "argument number %d:", argnum);
	1092	return SWIG_Python_AddErrMesg(mesg, 1);
	1093	} else {
	1094	return 0;
	1095	}
	1096	}
	1097
	1098
	1099	/* -----------------------------------------------------------------------------
	1100	* pointers/data manipulation
	1101	* ----------------------------------------------------------------------------- */
	1102
	1103	/* Convert a pointer value */
	1104	SWIGRUNTIME int
	1105	SWIG_Python_ConvertPtr(PyObject obj, void ptr, swig_type_info ty, int flags) {
	1106	swig_type_info *tc;
	1107	const char *c = 0;
	1108	static PyObject *SWIG_this = 0;
	1109	int newref = 0;
	1110	PyObject *pyobj = 0;
	1111	void *vptr;
	1112
	1113	if (!obj) return 0;
	1114	if (obj == Py_None) {
	1115	*ptr = 0;
	1116	return 0;
	1117	}
	1118
	1119	#ifdef SWIG_COBJECT_TYPES
	1120	if (!(PySwigObject_Check(obj))) {
	1121	if (!SWIG_this)
	1122	SWIG_this = PyString_FromString("this");
	1123	pyobj = obj;
	1124	obj = PyObject_GetAttr(obj,SWIG_this);
	1125	newref = 1;
	1126	if (!obj) goto type_error;
	1127	if (!PySwigObject_Check(obj)) {
	1128	Py_DECREF(obj);
	1129	goto type_error;
	1130	}
	1131	}
	1132	vptr = PySwigObject_AsVoidPtr(obj);
	1133	c = (const char *) PySwigObject_GetDesc(obj);
	1134	if (newref) { Py_DECREF(obj); }
	1135	goto type_check;
	1136	#else
	1137	if (!(PyString_Check(obj))) {
	1138	if (!SWIG_this)
	1139	SWIG_this = PyString_FromString("this");
	1140	pyobj = obj;
	1141	obj = PyObject_GetAttr(obj,SWIG_this);
	1142	newref = 1;
	1143	if (!obj) goto type_error;
	1144	if (!PyString_Check(obj)) {
	1145	Py_DECREF(obj);
	1146	goto type_error;
	1147	}
	1148	}
	1149	c = PyString_AS_STRING(obj);
	1150	/* Pointer values must start with leading underscore */
	1151	c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
	1152	if (newref) { Py_DECREF(obj); }
	1153	if (!c) goto type_error;
	1154	#endif
	1155
	1156	type_check:
	1157
	1158	if (ty) {
	1159	tc = SWIG_TypeCheck(c,ty);
	1160	if (!tc) goto type_error;
	1161	*ptr = SWIG_TypeCast(tc,vptr);
	1162	} else {
	1163	*ptr = vptr;
	1164	}
	1165
	1166	if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
	1167	PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
	1168	}
	1169	return 0;
	1170
	1171	type_error:
	1172	PyErr_Clear();
	1173	if (pyobj && !obj) {
	1174	obj = pyobj;
	1175	if (PyCFunction_Check(obj)) {
	1176	/* here we get the method pointer for callbacks */
	1177	char doc = (((PyCFunctionObject )obj) -> m_ml -> ml_doc);
	1178	c = doc ? strstr(doc, "swig_ptr: ") : 0;
	1179	if (c) {
	1180	c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
	1181	if (!c) goto type_error;
	1182	goto type_check;
	1183	}
	1184	}
	1185	}
	1186	if (flags & SWIG_POINTER_EXCEPTION) {
	1187	if (ty) {
	1188	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
	1189	} else {
	1190	SWIG_Python_TypeError("C/C++ pointer", obj);
	1191	}
	1192	}
	1193	return -1;
	1194	}
	1195
	1196	/* Convert a pointer value, signal an exception on a type mismatch */
	1197	SWIGRUNTIME void *
	1198	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int argnum, int flags) {
	1199	void *result;
	1200	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
	1201	PyErr_Clear();
	1202	if (flags & SWIG_POINTER_EXCEPTION) {
	1203	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
	1204	SWIG_Python_ArgFail(argnum);
	1205	}
	1206	}
	1207	return result;
	1208	}
	1209
	1210	/* Convert a packed value value */
	1211	SWIGRUNTIME int
	1212	SWIG_Python_ConvertPacked(PyObject obj, void ptr, size_t sz, swig_type_info *ty, int flags) {
	1213	swig_type_info *tc;
	1214	const char *c = 0;
	1215
	1216	#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
	1217	c = PySwigPacked_UnpackData(obj, ptr, sz);
	1218	#else
	1219	if ((!obj) \|\| (!PyString_Check(obj))) goto type_error;
	1220	c = PyString_AS_STRING(obj);
	1221	/* Pointer values must start with leading underscore */
	1222	c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
	1223	#endif
	1224	if (!c) goto type_error;
	1225	if (ty) {
	1226	tc = SWIG_TypeCheck(c,ty);
	1227	if (!tc) goto type_error;
	1228	}
	1229	return 0;
	1230
	1231	type_error:
	1232	PyErr_Clear();
	1233	if (flags & SWIG_POINTER_EXCEPTION) {
	1234	if (ty) {
	1235	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
	1236	} else {
	1237	SWIG_Python_TypeError("C/C++ packed data", obj);
	1238	}
	1239	}
	1240	return -1;
	1241	}
	1242
	1243	/* Create a new array object */
	1244	SWIGRUNTIME PyObject *
	1245	SWIG_Python_NewPointerObj(void ptr, swig_type_info type, int own) {
	1246	PyObject *robj = 0;
	1247	if (!ptr) {
	1248	Py_INCREF(Py_None);
	1249	return Py_None;
	1250	}
	1251	#ifdef SWIG_COBJECT_TYPES
	1252	robj = PySwigObject_FromVoidPtrAndDesc((void ) ptr, (char )type->name);
	1253	#else
	1254	{
	1255	char result[SWIG_BUFFER_SIZE];
	1256	robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
	1257	PyString_FromString(result) : 0;
	1258	}
	1259	#endif
	1260	if (!robj \|\| (robj == Py_None)) return robj;
	1261	if (type->clientdata) {
	1262	PyObject *inst;
	1263	PyObject args = Py_BuildValue((char)"(O)", robj);
	1264	Py_DECREF(robj);
	1265	inst = PyObject_CallObject((PyObject *) type->clientdata, args);
	1266	Py_DECREF(args);
	1267	if (inst) {
	1268	if (own) {
	1269	PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
	1270	}
	1271	robj = inst;
	1272	}
	1273	}
	1274	return robj;
	1275	}
	1276
	1277	SWIGRUNTIME PyObject *
	1278	SWIG_Python_NewPackedObj(void ptr, size_t sz, swig_type_info type) {
	1279	PyObject *robj = 0;
	1280	if (!ptr) {
	1281	Py_INCREF(Py_None);
	1282	return Py_None;
	1283	}
	1284	#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
	1285	robj = PySwigPacked_FromDataAndDesc((void ) ptr, sz, (char )type->name);
	1286	#else
	1287	{
	1288	char result[SWIG_BUFFER_SIZE];
	1289	robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
	1290	PyString_FromString(result) : 0;
	1291	}
	1292	#endif
	1293	return robj;
	1294	}
	1295
	1296	/* -----------------------------------------------------------------------------*
	1297	* Get type list
	1298	* -----------------------------------------------------------------------------*/
	1299
	1300	#ifdef SWIG_LINK_RUNTIME
	1301	void SWIG_ReturnGlobalTypeList(void );
	1302	#endif
	1303
	1304	SWIGRUNTIME swig_type_info **
	1305	SWIG_Python_GetTypeListHandle() {
	1306	static void type_pointer = (void )0;
	1307	/* first check if module already created */
	1308	if (!type_pointer) {
	1309	#ifdef SWIG_LINK_RUNTIME
	1310	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
	1311	#else
	1312	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
	1313	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
	1314	if (PyErr_Occurred()) {
	1315	PyErr_Clear();
	1316	type_pointer = (void *)0;
	1317	}
	1318	}
	1319	#endif
	1320	return (swig_type_info **) type_pointer;
	1321	}
	1322
	1323	/*
	1324	Search for a swig_type_info structure
	1325	*/
	1326	SWIGRUNTIMEINLINE swig_type_info *
	1327	SWIG_Python_GetTypeList() {
	1328	swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
	1329	return tlh ? tlh : (swig_type_info)0;
	1330	}
	1331
	1332	#define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
	1333
	1334	#ifdef __cplusplus
	1335	}
	1336	#endif
	1337
	1338
	1339	/* -------- TYPES TABLE (BEGIN) -------- */
	1340
	1341	#define SWIGTYPE_p_wxRect swig_types[0]
	1342	#define SWIGTYPE_p_wxGIFAnimationCtrl swig_types[1]
	1343	#define SWIGTYPE_p_wxObject swig_types[2]
	1344	#define SWIGTYPE_p_unsigned_char swig_types[3]
	1345	#define SWIGTYPE_p_wxColour swig_types[4]
	1346	#define SWIGTYPE_p_wxAnimationPlayer swig_types[5]
	1347	#define SWIGTYPE_p_wxWindow swig_types[6]
	1348	#define SWIGTYPE_p_unsigned_long swig_types[7]
	1349	#define SWIGTYPE_p_wxBitmap swig_types[8]
	1350	#define SWIGTYPE_p_form_ops_t swig_types[9]
	1351	#define SWIGTYPE_p_unsigned_int swig_types[10]
	1352	#define SWIGTYPE_unsigned_int swig_types[11]
	1353	#define SWIGTYPE_p_wxDuplexMode swig_types[12]
	1354	#define SWIGTYPE_p_wxGIFAnimation swig_types[13]
	1355	#define SWIGTYPE_p_char swig_types[14]
	1356	#define SWIGTYPE_p_wxAnimationBase swig_types[15]
	1357	#define SWIGTYPE_p_wxPoint swig_types[16]
	1358	#define SWIGTYPE_p_wxDC swig_types[17]
	1359	#define SWIGTYPE_p_wxEvtHandler swig_types[18]
	1360	#define SWIGTYPE_std__ptrdiff_t swig_types[19]
	1361	#define SWIGTYPE_ptrdiff_t swig_types[20]
	1362	#define SWIGTYPE_p_wxControl swig_types[21]
	1363	#define SWIGTYPE_p_wxPaperSize swig_types[22]
	1364	#define SWIGTYPE_p_wxImage swig_types[23]
	1365	#define SWIGTYPE_p_wxSize swig_types[24]
	1366	#define SWIGTYPE_p_int swig_types[25]
	1367	static swig_type_info *swig_types[27];
	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	/@c:\\PROJECTS\\SWIG-cvs\\Lib\\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	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
	2460	return resultobj;
	2461	fail:
	2462	return NULL;
	2463	}
	2464
	2465
	2466	static PyObject _wrap_AnimationPlayer_GetDisposalMethod(PyObject , PyObject args, PyObject kwargs) {
	2467	PyObject *resultobj;
	2468	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2469	int arg2 ;
	2470	wxAnimationDisposal result;
	2471	PyObject * obj0 = 0 ;
	2472	PyObject * obj1 = 0 ;
	2473	char *kwnames[] = {
	2474	(char ) "self",(char ) "i", NULL
	2475	};
	2476
	2477	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetDisposalMethod",kwnames,&obj0,&obj1)) goto fail;
	2478	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2479	if (SWIG_arg_fail(1)) SWIG_fail;
	2480	{
	2481	arg2 = (int)(SWIG_As_int(obj1));
	2482	if (SWIG_arg_fail(2)) SWIG_fail;
	2483	}
	2484	{
	2485	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2486	result = (wxAnimationDisposal)((wxAnimationPlayer const *)arg1)->GetDisposalMethod(arg2);
	2487
	2488	wxPyEndAllowThreads(__tstate);
	2489	if (PyErr_Occurred()) SWIG_fail;
	2490	}
	2491	resultobj = SWIG_From_int((result));
	2492	return resultobj;
	2493	fail:
	2494	return NULL;
	2495	}
	2496
	2497
	2498	static PyObject _wrap_AnimationPlayer_GetFrameRect(PyObject , PyObject args, PyObject kwargs) {
	2499	PyObject *resultobj;
	2500	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2501	int arg2 ;
	2502	wxRect result;
	2503	PyObject * obj0 = 0 ;
	2504	PyObject * obj1 = 0 ;
	2505	char *kwnames[] = {
	2506	(char ) "self",(char ) "i", NULL
	2507	};
	2508
	2509	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetFrameRect",kwnames,&obj0,&obj1)) goto fail;
	2510	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2511	if (SWIG_arg_fail(1)) SWIG_fail;
	2512	{
	2513	arg2 = (int)(SWIG_As_int(obj1));
	2514	if (SWIG_arg_fail(2)) SWIG_fail;
	2515	}
	2516	{
	2517	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2518	result = ((wxAnimationPlayer const *)arg1)->GetFrameRect(arg2);
	2519
	2520	wxPyEndAllowThreads(__tstate);
	2521	if (PyErr_Occurred()) SWIG_fail;
	2522	}
	2523	{
	2524	wxRect * resultptr;
	2525	resultptr = new wxRect((wxRect &)(result));
	2526	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
	2527	}
	2528	return resultobj;
	2529	fail:
	2530	return NULL;
	2531	}
	2532
	2533
	2534	static PyObject _wrap_AnimationPlayer_GetDelay(PyObject , PyObject args, PyObject kwargs) {
	2535	PyObject *resultobj;
	2536	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2537	int arg2 ;
	2538	int result;
	2539	PyObject * obj0 = 0 ;
	2540	PyObject * obj1 = 0 ;
	2541	char *kwnames[] = {
	2542	(char ) "self",(char ) "i", NULL
	2543	};
	2544
	2545	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetDelay",kwnames,&obj0,&obj1)) goto fail;
	2546	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2547	if (SWIG_arg_fail(1)) SWIG_fail;
	2548	{
	2549	arg2 = (int)(SWIG_As_int(obj1));
	2550	if (SWIG_arg_fail(2)) SWIG_fail;
	2551	}
	2552	{
	2553	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2554	result = (int)((wxAnimationPlayer const *)arg1)->GetDelay(arg2);
	2555
	2556	wxPyEndAllowThreads(__tstate);
	2557	if (PyErr_Occurred()) SWIG_fail;
	2558	}
	2559	{
	2560	resultobj = SWIG_From_int((int)(result));
	2561	}
	2562	return resultobj;
	2563	fail:
	2564	return NULL;
	2565	}
	2566
	2567
	2568	static PyObject _wrap_AnimationPlayer_GetLogicalScreenSize(PyObject , PyObject args, PyObject kwargs) {
	2569	PyObject *resultobj;
	2570	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2571	wxSize result;
	2572	PyObject * obj0 = 0 ;
	2573	char *kwnames[] = {
	2574	(char *) "self", NULL
	2575	};
	2576
	2577	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetLogicalScreenSize",kwnames,&obj0)) goto fail;
	2578	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2579	if (SWIG_arg_fail(1)) SWIG_fail;
	2580	{
	2581	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2582	result = ((wxAnimationPlayer const *)arg1)->GetLogicalScreenSize();
	2583
	2584	wxPyEndAllowThreads(__tstate);
	2585	if (PyErr_Occurred()) SWIG_fail;
	2586	}
	2587	{
	2588	wxSize * resultptr;
	2589	resultptr = new wxSize((wxSize &)(result));
	2590	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
	2591	}
	2592	return resultobj;
	2593	fail:
	2594	return NULL;
	2595	}
	2596
	2597
	2598	static PyObject _wrap_AnimationPlayer_GetBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	2599	PyObject *resultobj;
	2600	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2601	wxColour *arg2 = 0 ;
	2602	bool result;
	2603	wxColour temp2 ;
	2604	PyObject * obj0 = 0 ;
	2605	PyObject * obj1 = 0 ;
	2606	char *kwnames[] = {
	2607	(char ) "self",(char ) "col", NULL
	2608	};
	2609
	2610	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
	2611	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2612	if (SWIG_arg_fail(1)) SWIG_fail;
	2613	{
	2614	arg2 = &temp2;
	2615	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	2616	}
	2617	{
	2618	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2619	result = (bool)((wxAnimationPlayer const )arg1)->GetBackgroundColour(arg2);
	2620
	2621	wxPyEndAllowThreads(__tstate);
	2622	if (PyErr_Occurred()) SWIG_fail;
	2623	}
	2624	{
	2625	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2626	}
	2627	return resultobj;
	2628	fail:
	2629	return NULL;
	2630	}
	2631
	2632
	2633	static PyObject _wrap_AnimationPlayer_GetTransparentColour(PyObject , PyObject args, PyObject kwargs) {
	2634	PyObject *resultobj;
	2635	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2636	wxColour *arg2 = 0 ;
	2637	bool result;
	2638	wxColour temp2 ;
	2639	PyObject * obj0 = 0 ;
	2640	PyObject * obj1 = 0 ;
	2641	char *kwnames[] = {
	2642	(char ) "self",(char ) "col", NULL
	2643	};
	2644
	2645	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_GetTransparentColour",kwnames,&obj0,&obj1)) goto fail;
	2646	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2647	if (SWIG_arg_fail(1)) SWIG_fail;
	2648	{
	2649	arg2 = &temp2;
	2650	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	2651	}
	2652	{
	2653	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2654	result = (bool)((wxAnimationPlayer const )arg1)->GetTransparentColour(arg2);
	2655
	2656	wxPyEndAllowThreads(__tstate);
	2657	if (PyErr_Occurred()) SWIG_fail;
	2658	}
	2659	{
	2660	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2661	}
	2662	return resultobj;
	2663	fail:
	2664	return NULL;
	2665	}
	2666
	2667
	2668	static PyObject _wrap_AnimationPlayer_PlayFrame(PyObject , PyObject args, PyObject kwargs) {
	2669	PyObject *resultobj;
	2670	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2671	int arg2 ;
	2672	wxWindow *arg3 = 0 ;
	2673	wxPoint *arg4 = 0 ;
	2674	bool result;
	2675	wxPoint temp4 ;
	2676	PyObject * obj0 = 0 ;
	2677	PyObject * obj1 = 0 ;
	2678	PyObject * obj2 = 0 ;
	2679	PyObject * obj3 = 0 ;
	2680	char *kwnames[] = {
	2681	(char ) "self",(char ) "frame",(char ) "window",(char ) "pos", NULL
	2682	};
	2683
	2684	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AnimationPlayer_PlayFrame",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
	2685	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2686	if (SWIG_arg_fail(1)) SWIG_fail;
	2687	{
	2688	arg2 = (int)(SWIG_As_int(obj1));
	2689	if (SWIG_arg_fail(2)) SWIG_fail;
	2690	}
	2691	{
	2692	SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	2693	if (SWIG_arg_fail(3)) SWIG_fail;
	2694	if (arg3 == NULL) {
	2695	SWIG_null_ref("wxWindow");
	2696	}
	2697	if (SWIG_arg_fail(3)) SWIG_fail;
	2698	}
	2699	{
	2700	arg4 = &temp4;
	2701	if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
	2702	}
	2703	{
	2704	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2705	result = (bool)(arg1)->PlayFrame(arg2,arg3,(wxPoint const &)arg4);
	2706
	2707	wxPyEndAllowThreads(__tstate);
	2708	if (PyErr_Occurred()) SWIG_fail;
	2709	}
	2710	{
	2711	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2712	}
	2713	return resultobj;
	2714	fail:
	2715	return NULL;
	2716	}
	2717
	2718
	2719	static PyObject _wrap_AnimationPlayer_PlayNextFrame(PyObject , PyObject args, PyObject kwargs) {
	2720	PyObject *resultobj;
	2721	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2722	bool result;
	2723	PyObject * obj0 = 0 ;
	2724	char *kwnames[] = {
	2725	(char *) "self", NULL
	2726	};
	2727
	2728	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_PlayNextFrame",kwnames,&obj0)) goto fail;
	2729	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2730	if (SWIG_arg_fail(1)) SWIG_fail;
	2731	{
	2732	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2733	result = (bool)(arg1)->PlayFrame();
	2734
	2735	wxPyEndAllowThreads(__tstate);
	2736	if (PyErr_Occurred()) SWIG_fail;
	2737	}
	2738	{
	2739	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	2740	}
	2741	return resultobj;
	2742	fail:
	2743	return NULL;
	2744	}
	2745
	2746
	2747	static PyObject _wrap_AnimationPlayer_DrawFrame(PyObject , PyObject args, PyObject kwargs) {
	2748	PyObject *resultobj;
	2749	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2750	int arg2 ;
	2751	wxDC *arg3 = 0 ;
	2752	wxPoint *arg4 = 0 ;
	2753	wxPoint temp4 ;
	2754	PyObject * obj0 = 0 ;
	2755	PyObject * obj1 = 0 ;
	2756	PyObject * obj2 = 0 ;
	2757	PyObject * obj3 = 0 ;
	2758	char *kwnames[] = {
	2759	(char ) "self",(char ) "frame",(char ) "dc",(char ) "pos", NULL
	2760	};
	2761
	2762	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AnimationPlayer_DrawFrame",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
	2763	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2764	if (SWIG_arg_fail(1)) SWIG_fail;
	2765	{
	2766	arg2 = (int)(SWIG_As_int(obj1));
	2767	if (SWIG_arg_fail(2)) SWIG_fail;
	2768	}
	2769	{
	2770	SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION \| 0);
	2771	if (SWIG_arg_fail(3)) SWIG_fail;
	2772	if (arg3 == NULL) {
	2773	SWIG_null_ref("wxDC");
	2774	}
	2775	if (SWIG_arg_fail(3)) SWIG_fail;
	2776	}
	2777	{
	2778	arg4 = &temp4;
	2779	if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
	2780	}
	2781	{
	2782	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2783	(arg1)->DrawFrame(arg2,arg3,(wxPoint const &)arg4);
	2784
	2785	wxPyEndAllowThreads(__tstate);
	2786	if (PyErr_Occurred()) SWIG_fail;
	2787	}
	2788	Py_INCREF(Py_None); resultobj = Py_None;
	2789	return resultobj;
	2790	fail:
	2791	return NULL;
	2792	}
	2793
	2794
	2795	static PyObject _wrap_AnimationPlayer_DrawBackground(PyObject , PyObject args, PyObject kwargs) {
	2796	PyObject *resultobj;
	2797	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2798	wxDC *arg2 = 0 ;
	2799	wxPoint *arg3 = 0 ;
	2800	wxColour *arg4 = 0 ;
	2801	wxPoint temp3 ;
	2802	wxColour temp4 ;
	2803	PyObject * obj0 = 0 ;
	2804	PyObject * obj1 = 0 ;
	2805	PyObject * obj2 = 0 ;
	2806	PyObject * obj3 = 0 ;
	2807	char *kwnames[] = {
	2808	(char ) "self",(char ) "dc",(char ) "pos",(char ) "colour", NULL
	2809	};
	2810
	2811	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AnimationPlayer_DrawBackground",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
	2812	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2813	if (SWIG_arg_fail(1)) SWIG_fail;
	2814	{
	2815	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION \| 0);
	2816	if (SWIG_arg_fail(2)) SWIG_fail;
	2817	if (arg2 == NULL) {
	2818	SWIG_null_ref("wxDC");
	2819	}
	2820	if (SWIG_arg_fail(2)) SWIG_fail;
	2821	}
	2822	{
	2823	arg3 = &temp3;
	2824	if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
	2825	}
	2826	{
	2827	arg4 = &temp4;
	2828	if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
	2829	}
	2830	{
	2831	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2832	(arg1)->DrawBackground(arg2,(wxPoint const &)arg3,(wxColour const &)*arg4);
	2833
	2834	wxPyEndAllowThreads(__tstate);
	2835	if (PyErr_Occurred()) SWIG_fail;
	2836	}
	2837	Py_INCREF(Py_None); resultobj = Py_None;
	2838	return resultobj;
	2839	fail:
	2840	return NULL;
	2841	}
	2842
	2843
	2844	static PyObject _wrap_AnimationPlayer_ClearCache(PyObject , PyObject args, PyObject kwargs) {
	2845	PyObject *resultobj;
	2846	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2847	PyObject * obj0 = 0 ;
	2848	char *kwnames[] = {
	2849	(char *) "self", NULL
	2850	};
	2851
	2852	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_ClearCache",kwnames,&obj0)) goto fail;
	2853	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2854	if (SWIG_arg_fail(1)) SWIG_fail;
	2855	{
	2856	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2857	(arg1)->ClearCache();
	2858
	2859	wxPyEndAllowThreads(__tstate);
	2860	if (PyErr_Occurred()) SWIG_fail;
	2861	}
	2862	Py_INCREF(Py_None); resultobj = Py_None;
	2863	return resultobj;
	2864	fail:
	2865	return NULL;
	2866	}
	2867
	2868
	2869	static PyObject _wrap_AnimationPlayer_SaveBackground(PyObject , PyObject args, PyObject kwargs) {
	2870	PyObject *resultobj;
	2871	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2872	wxRect *arg2 = 0 ;
	2873	wxRect temp2 ;
	2874	PyObject * obj0 = 0 ;
	2875	PyObject * obj1 = 0 ;
	2876	char *kwnames[] = {
	2877	(char ) "self",(char ) "rect", NULL
	2878	};
	2879
	2880	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationPlayer_SaveBackground",kwnames,&obj0,&obj1)) goto fail;
	2881	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2882	if (SWIG_arg_fail(1)) SWIG_fail;
	2883	{
	2884	arg2 = &temp2;
	2885	if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
	2886	}
	2887	{
	2888	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2889	(arg1)->SaveBackground((wxRect const &)*arg2);
	2890
	2891	wxPyEndAllowThreads(__tstate);
	2892	if (PyErr_Occurred()) SWIG_fail;
	2893	}
	2894	Py_INCREF(Py_None); resultobj = Py_None;
	2895	return resultobj;
	2896	fail:
	2897	return NULL;
	2898	}
	2899
	2900
	2901	static PyObject _wrap_AnimationPlayer_GetBackingStore(PyObject , PyObject args, PyObject kwargs) {
	2902	PyObject *resultobj;
	2903	wxAnimationPlayer arg1 = (wxAnimationPlayer ) 0 ;
	2904	wxBitmap *result;
	2905	PyObject * obj0 = 0 ;
	2906	char *kwnames[] = {
	2907	(char *) "self", NULL
	2908	};
	2909
	2910	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationPlayer_GetBackingStore",kwnames,&obj0)) goto fail;
	2911	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationPlayer, SWIG_POINTER_EXCEPTION \| 0);
	2912	if (SWIG_arg_fail(1)) SWIG_fail;
	2913	{
	2914	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2915	{
	2916	wxBitmap &_result_ref = (arg1)->GetBackingStore();
	2917	result = (wxBitmap *) &_result_ref;
	2918	}
	2919
	2920	wxPyEndAllowThreads(__tstate);
	2921	if (PyErr_Occurred()) SWIG_fail;
	2922	}
	2923	{
	2924	wxBitmap* resultptr = new wxBitmap(*result);
	2925	resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
	2926	}
	2927	return resultobj;
	2928	fail:
	2929	return NULL;
	2930	}
	2931
	2932
	2933	static PyObject * AnimationPlayer_swigregister(PyObject , PyObject args) {
	2934	PyObject *obj;
	2935	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	2936	SWIG_TypeClientData(SWIGTYPE_p_wxAnimationPlayer, obj);
	2937	Py_INCREF(obj);
	2938	return Py_BuildValue((char *)"");
	2939	}
	2940	static PyObject _wrap_delete_AnimationBase(PyObject , PyObject args, PyObject kwargs) {
	2941	PyObject *resultobj;
	2942	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	2943	PyObject * obj0 = 0 ;
	2944	char *kwnames[] = {
	2945	(char *) "self", NULL
	2946	};
	2947
	2948	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AnimationBase",kwnames,&obj0)) goto fail;
	2949	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	2950	if (SWIG_arg_fail(1)) SWIG_fail;
	2951	{
	2952	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2953	delete arg1;
	2954
	2955	wxPyEndAllowThreads(__tstate);
	2956	if (PyErr_Occurred()) SWIG_fail;
	2957	}
	2958	Py_INCREF(Py_None); resultobj = Py_None;
	2959	return resultobj;
	2960	fail:
	2961	return NULL;
	2962	}
	2963
	2964
	2965	static PyObject _wrap_AnimationBase_GetFrameCount(PyObject , PyObject args, PyObject kwargs) {
	2966	PyObject *resultobj;
	2967	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	2968	int result;
	2969	PyObject * obj0 = 0 ;
	2970	char *kwnames[] = {
	2971	(char *) "self", NULL
	2972	};
	2973
	2974	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationBase_GetFrameCount",kwnames,&obj0)) goto fail;
	2975	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	2976	if (SWIG_arg_fail(1)) SWIG_fail;
	2977	{
	2978	PyThreadState* __tstate = wxPyBeginAllowThreads();
	2979	result = (int)((wxAnimationBase const *)arg1)->GetFrameCount();
	2980
	2981	wxPyEndAllowThreads(__tstate);
	2982	if (PyErr_Occurred()) SWIG_fail;
	2983	}
	2984	{
	2985	resultobj = SWIG_From_int((int)(result));
	2986	}
	2987	return resultobj;
	2988	fail:
	2989	return NULL;
	2990	}
	2991
	2992
	2993	static PyObject _wrap_AnimationBase_GetFrame(PyObject , PyObject args, PyObject kwargs) {
	2994	PyObject *resultobj;
	2995	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	2996	int arg2 ;
	2997	wxImage *result;
	2998	PyObject * obj0 = 0 ;
	2999	PyObject * obj1 = 0 ;
	3000	char *kwnames[] = {
	3001	(char ) "self",(char ) "i", NULL
	3002	};
	3003
	3004	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetFrame",kwnames,&obj0,&obj1)) goto fail;
	3005	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3006	if (SWIG_arg_fail(1)) SWIG_fail;
	3007	{
	3008	arg2 = (int)(SWIG_As_int(obj1));
	3009	if (SWIG_arg_fail(2)) SWIG_fail;
	3010	}
	3011	{
	3012	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3013	result = (wxImage )((wxAnimationBase const )arg1)->GetFrame(arg2);
	3014
	3015	wxPyEndAllowThreads(__tstate);
	3016	if (PyErr_Occurred()) SWIG_fail;
	3017	}
	3018	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
	3019	return resultobj;
	3020	fail:
	3021	return NULL;
	3022	}
	3023
	3024
	3025	static PyObject _wrap_AnimationBase_GetDisposalMethod(PyObject , PyObject args, PyObject kwargs) {
	3026	PyObject *resultobj;
	3027	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3028	int arg2 ;
	3029	wxAnimationDisposal result;
	3030	PyObject * obj0 = 0 ;
	3031	PyObject * obj1 = 0 ;
	3032	char *kwnames[] = {
	3033	(char ) "self",(char ) "i", NULL
	3034	};
	3035
	3036	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetDisposalMethod",kwnames,&obj0,&obj1)) goto fail;
	3037	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3038	if (SWIG_arg_fail(1)) SWIG_fail;
	3039	{
	3040	arg2 = (int)(SWIG_As_int(obj1));
	3041	if (SWIG_arg_fail(2)) SWIG_fail;
	3042	}
	3043	{
	3044	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3045	result = (wxAnimationDisposal)((wxAnimationBase const *)arg1)->GetDisposalMethod(arg2);
	3046
	3047	wxPyEndAllowThreads(__tstate);
	3048	if (PyErr_Occurred()) SWIG_fail;
	3049	}
	3050	resultobj = SWIG_From_int((result));
	3051	return resultobj;
	3052	fail:
	3053	return NULL;
	3054	}
	3055
	3056
	3057	static PyObject _wrap_AnimationBase_GetFrameRect(PyObject , PyObject args, PyObject kwargs) {
	3058	PyObject *resultobj;
	3059	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3060	int arg2 ;
	3061	wxRect result;
	3062	PyObject * obj0 = 0 ;
	3063	PyObject * obj1 = 0 ;
	3064	char *kwnames[] = {
	3065	(char ) "self",(char ) "i", NULL
	3066	};
	3067
	3068	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetFrameRect",kwnames,&obj0,&obj1)) goto fail;
	3069	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3070	if (SWIG_arg_fail(1)) SWIG_fail;
	3071	{
	3072	arg2 = (int)(SWIG_As_int(obj1));
	3073	if (SWIG_arg_fail(2)) SWIG_fail;
	3074	}
	3075	{
	3076	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3077	result = ((wxAnimationBase const *)arg1)->GetFrameRect(arg2);
	3078
	3079	wxPyEndAllowThreads(__tstate);
	3080	if (PyErr_Occurred()) SWIG_fail;
	3081	}
	3082	{
	3083	wxRect * resultptr;
	3084	resultptr = new wxRect((wxRect &)(result));
	3085	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
	3086	}
	3087	return resultobj;
	3088	fail:
	3089	return NULL;
	3090	}
	3091
	3092
	3093	static PyObject _wrap_AnimationBase_GetDelay(PyObject , PyObject args, PyObject kwargs) {
	3094	PyObject *resultobj;
	3095	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3096	int arg2 ;
	3097	int result;
	3098	PyObject * obj0 = 0 ;
	3099	PyObject * obj1 = 0 ;
	3100	char *kwnames[] = {
	3101	(char ) "self",(char ) "i", NULL
	3102	};
	3103
	3104	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetDelay",kwnames,&obj0,&obj1)) goto fail;
	3105	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3106	if (SWIG_arg_fail(1)) SWIG_fail;
	3107	{
	3108	arg2 = (int)(SWIG_As_int(obj1));
	3109	if (SWIG_arg_fail(2)) SWIG_fail;
	3110	}
	3111	{
	3112	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3113	result = (int)((wxAnimationBase const *)arg1)->GetDelay(arg2);
	3114
	3115	wxPyEndAllowThreads(__tstate);
	3116	if (PyErr_Occurred()) SWIG_fail;
	3117	}
	3118	{
	3119	resultobj = SWIG_From_int((int)(result));
	3120	}
	3121	return resultobj;
	3122	fail:
	3123	return NULL;
	3124	}
	3125
	3126
	3127	static PyObject _wrap_AnimationBase_GetLogicalScreenSize(PyObject , PyObject args, PyObject kwargs) {
	3128	PyObject *resultobj;
	3129	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3130	wxSize result;
	3131	PyObject * obj0 = 0 ;
	3132	char *kwnames[] = {
	3133	(char *) "self", NULL
	3134	};
	3135
	3136	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationBase_GetLogicalScreenSize",kwnames,&obj0)) goto fail;
	3137	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3138	if (SWIG_arg_fail(1)) SWIG_fail;
	3139	{
	3140	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3141	result = ((wxAnimationBase const *)arg1)->GetLogicalScreenSize();
	3142
	3143	wxPyEndAllowThreads(__tstate);
	3144	if (PyErr_Occurred()) SWIG_fail;
	3145	}
	3146	{
	3147	wxSize * resultptr;
	3148	resultptr = new wxSize((wxSize &)(result));
	3149	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
	3150	}
	3151	return resultobj;
	3152	fail:
	3153	return NULL;
	3154	}
	3155
	3156
	3157	static PyObject _wrap_AnimationBase_GetBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	3158	PyObject *resultobj;
	3159	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3160	wxColour *arg2 = 0 ;
	3161	bool result;
	3162	wxColour temp2 ;
	3163	PyObject * obj0 = 0 ;
	3164	PyObject * obj1 = 0 ;
	3165	char *kwnames[] = {
	3166	(char ) "self",(char ) "col", NULL
	3167	};
	3168
	3169	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
	3170	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3171	if (SWIG_arg_fail(1)) SWIG_fail;
	3172	{
	3173	arg2 = &temp2;
	3174	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3175	}
	3176	{
	3177	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3178	result = (bool)((wxAnimationBase const )arg1)->GetBackgroundColour(arg2);
	3179
	3180	wxPyEndAllowThreads(__tstate);
	3181	if (PyErr_Occurred()) SWIG_fail;
	3182	}
	3183	{
	3184	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3185	}
	3186	return resultobj;
	3187	fail:
	3188	return NULL;
	3189	}
	3190
	3191
	3192	static PyObject _wrap_AnimationBase_GetTransparentColour(PyObject , PyObject args, PyObject kwargs) {
	3193	PyObject *resultobj;
	3194	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3195	wxColour *arg2 = 0 ;
	3196	bool result;
	3197	wxColour temp2 ;
	3198	PyObject * obj0 = 0 ;
	3199	PyObject * obj1 = 0 ;
	3200	char *kwnames[] = {
	3201	(char ) "self",(char ) "col", NULL
	3202	};
	3203
	3204	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_GetTransparentColour",kwnames,&obj0,&obj1)) goto fail;
	3205	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3206	if (SWIG_arg_fail(1)) SWIG_fail;
	3207	{
	3208	arg2 = &temp2;
	3209	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3210	}
	3211	{
	3212	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3213	result = (bool)((wxAnimationBase const )arg1)->GetTransparentColour(arg2);
	3214
	3215	wxPyEndAllowThreads(__tstate);
	3216	if (PyErr_Occurred()) SWIG_fail;
	3217	}
	3218	{
	3219	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3220	}
	3221	return resultobj;
	3222	fail:
	3223	return NULL;
	3224	}
	3225
	3226
	3227	static PyObject _wrap_AnimationBase_IsValid(PyObject , PyObject args, PyObject kwargs) {
	3228	PyObject *resultobj;
	3229	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3230	bool result;
	3231	PyObject * obj0 = 0 ;
	3232	char *kwnames[] = {
	3233	(char *) "self", NULL
	3234	};
	3235
	3236	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AnimationBase_IsValid",kwnames,&obj0)) goto fail;
	3237	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3238	if (SWIG_arg_fail(1)) SWIG_fail;
	3239	{
	3240	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3241	result = (bool)((wxAnimationBase const *)arg1)->IsValid();
	3242
	3243	wxPyEndAllowThreads(__tstate);
	3244	if (PyErr_Occurred()) SWIG_fail;
	3245	}
	3246	{
	3247	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3248	}
	3249	return resultobj;
	3250	fail:
	3251	return NULL;
	3252	}
	3253
	3254
	3255	static PyObject _wrap_AnimationBase_LoadFile(PyObject , PyObject args, PyObject kwargs) {
	3256	PyObject *resultobj;
	3257	wxAnimationBase arg1 = (wxAnimationBase ) 0 ;
	3258	wxString *arg2 = 0 ;
	3259	bool result;
	3260	bool temp2 = false ;
	3261	PyObject * obj0 = 0 ;
	3262	PyObject * obj1 = 0 ;
	3263	char *kwnames[] = {
	3264	(char ) "self",(char ) "filename", NULL
	3265	};
	3266
	3267	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AnimationBase_LoadFile",kwnames,&obj0,&obj1)) goto fail;
	3268	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAnimationBase, SWIG_POINTER_EXCEPTION \| 0);
	3269	if (SWIG_arg_fail(1)) SWIG_fail;
	3270	{
	3271	arg2 = wxString_in_helper(obj1);
	3272	if (arg2 == NULL) SWIG_fail;
	3273	temp2 = true;
	3274	}
	3275	{
	3276	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3277	result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
	3278
	3279	wxPyEndAllowThreads(__tstate);
	3280	if (PyErr_Occurred()) SWIG_fail;
	3281	}
	3282	{
	3283	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3284	}
	3285	{
	3286	if (temp2)
	3287	delete arg2;
	3288	}
	3289	return resultobj;
	3290	fail:
	3291	{
	3292	if (temp2)
	3293	delete arg2;
	3294	}
	3295	return NULL;
	3296	}
	3297
	3298
	3299	static PyObject * AnimationBase_swigregister(PyObject , PyObject args) {
	3300	PyObject *obj;
	3301	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	3302	SWIG_TypeClientData(SWIGTYPE_p_wxAnimationBase, obj);
	3303	Py_INCREF(obj);
	3304	return Py_BuildValue((char *)"");
	3305	}
	3306	static PyObject _wrap_new_GIFAnimation(PyObject , PyObject args, PyObject kwargs) {
	3307	PyObject *resultobj;
	3308	wxGIFAnimation *result;
	3309	char *kwnames[] = {
	3310	NULL
	3311	};
	3312
	3313	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFAnimation",kwnames)) goto fail;
	3314	{
	3315	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3316	result = (wxGIFAnimation *)new wxGIFAnimation();
	3317
	3318	wxPyEndAllowThreads(__tstate);
	3319	if (PyErr_Occurred()) SWIG_fail;
	3320	}
	3321	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFAnimation, 1);
	3322	return resultobj;
	3323	fail:
	3324	return NULL;
	3325	}
	3326
	3327
	3328	static PyObject _wrap_delete_GIFAnimation(PyObject , PyObject args, PyObject kwargs) {
	3329	PyObject *resultobj;
	3330	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3331	PyObject * obj0 = 0 ;
	3332	char *kwnames[] = {
	3333	(char *) "self", NULL
	3334	};
	3335
	3336	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GIFAnimation",kwnames,&obj0)) goto fail;
	3337	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3338	if (SWIG_arg_fail(1)) SWIG_fail;
	3339	{
	3340	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3341	delete arg1;
	3342
	3343	wxPyEndAllowThreads(__tstate);
	3344	if (PyErr_Occurred()) SWIG_fail;
	3345	}
	3346	Py_INCREF(Py_None); resultobj = Py_None;
	3347	return resultobj;
	3348	fail:
	3349	return NULL;
	3350	}
	3351
	3352
	3353	static PyObject _wrap_GIFAnimation_GetFrameCount(PyObject , PyObject args, PyObject kwargs) {
	3354	PyObject *resultobj;
	3355	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3356	int result;
	3357	PyObject * obj0 = 0 ;
	3358	char *kwnames[] = {
	3359	(char *) "self", NULL
	3360	};
	3361
	3362	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimation_GetFrameCount",kwnames,&obj0)) goto fail;
	3363	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3364	if (SWIG_arg_fail(1)) SWIG_fail;
	3365	{
	3366	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3367	result = (int)((wxGIFAnimation const *)arg1)->GetFrameCount();
	3368
	3369	wxPyEndAllowThreads(__tstate);
	3370	if (PyErr_Occurred()) SWIG_fail;
	3371	}
	3372	{
	3373	resultobj = SWIG_From_int((int)(result));
	3374	}
	3375	return resultobj;
	3376	fail:
	3377	return NULL;
	3378	}
	3379
	3380
	3381	static PyObject _wrap_GIFAnimation_GetFrame(PyObject , PyObject args, PyObject kwargs) {
	3382	PyObject *resultobj;
	3383	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3384	int arg2 ;
	3385	wxImage *result;
	3386	PyObject * obj0 = 0 ;
	3387	PyObject * obj1 = 0 ;
	3388	char *kwnames[] = {
	3389	(char ) "self",(char ) "i", NULL
	3390	};
	3391
	3392	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetFrame",kwnames,&obj0,&obj1)) goto fail;
	3393	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3394	if (SWIG_arg_fail(1)) SWIG_fail;
	3395	{
	3396	arg2 = (int)(SWIG_As_int(obj1));
	3397	if (SWIG_arg_fail(2)) SWIG_fail;
	3398	}
	3399	{
	3400	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3401	result = (wxImage )((wxGIFAnimation const )arg1)->GetFrame(arg2);
	3402
	3403	wxPyEndAllowThreads(__tstate);
	3404	if (PyErr_Occurred()) SWIG_fail;
	3405	}
	3406	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
	3407	return resultobj;
	3408	fail:
	3409	return NULL;
	3410	}
	3411
	3412
	3413	static PyObject _wrap_GIFAnimation_GetDisposalMethod(PyObject , PyObject args, PyObject kwargs) {
	3414	PyObject *resultobj;
	3415	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3416	int arg2 ;
	3417	wxAnimationDisposal result;
	3418	PyObject * obj0 = 0 ;
	3419	PyObject * obj1 = 0 ;
	3420	char *kwnames[] = {
	3421	(char ) "self",(char ) "i", NULL
	3422	};
	3423
	3424	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetDisposalMethod",kwnames,&obj0,&obj1)) goto fail;
	3425	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3426	if (SWIG_arg_fail(1)) SWIG_fail;
	3427	{
	3428	arg2 = (int)(SWIG_As_int(obj1));
	3429	if (SWIG_arg_fail(2)) SWIG_fail;
	3430	}
	3431	{
	3432	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3433	result = (wxAnimationDisposal)((wxGIFAnimation const *)arg1)->GetDisposalMethod(arg2);
	3434
	3435	wxPyEndAllowThreads(__tstate);
	3436	if (PyErr_Occurred()) SWIG_fail;
	3437	}
	3438	resultobj = SWIG_From_int((result));
	3439	return resultobj;
	3440	fail:
	3441	return NULL;
	3442	}
	3443
	3444
	3445	static PyObject _wrap_GIFAnimation_GetFrameRect(PyObject , PyObject args, PyObject kwargs) {
	3446	PyObject *resultobj;
	3447	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3448	int arg2 ;
	3449	wxRect result;
	3450	PyObject * obj0 = 0 ;
	3451	PyObject * obj1 = 0 ;
	3452	char *kwnames[] = {
	3453	(char ) "self",(char ) "i", NULL
	3454	};
	3455
	3456	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetFrameRect",kwnames,&obj0,&obj1)) goto fail;
	3457	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3458	if (SWIG_arg_fail(1)) SWIG_fail;
	3459	{
	3460	arg2 = (int)(SWIG_As_int(obj1));
	3461	if (SWIG_arg_fail(2)) SWIG_fail;
	3462	}
	3463	{
	3464	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3465	result = ((wxGIFAnimation const *)arg1)->GetFrameRect(arg2);
	3466
	3467	wxPyEndAllowThreads(__tstate);
	3468	if (PyErr_Occurred()) SWIG_fail;
	3469	}
	3470	{
	3471	wxRect * resultptr;
	3472	resultptr = new wxRect((wxRect &)(result));
	3473	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
	3474	}
	3475	return resultobj;
	3476	fail:
	3477	return NULL;
	3478	}
	3479
	3480
	3481	static PyObject _wrap_GIFAnimation_GetDelay(PyObject , PyObject args, PyObject kwargs) {
	3482	PyObject *resultobj;
	3483	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3484	int arg2 ;
	3485	int result;
	3486	PyObject * obj0 = 0 ;
	3487	PyObject * obj1 = 0 ;
	3488	char *kwnames[] = {
	3489	(char ) "self",(char ) "i", NULL
	3490	};
	3491
	3492	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetDelay",kwnames,&obj0,&obj1)) goto fail;
	3493	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3494	if (SWIG_arg_fail(1)) SWIG_fail;
	3495	{
	3496	arg2 = (int)(SWIG_As_int(obj1));
	3497	if (SWIG_arg_fail(2)) SWIG_fail;
	3498	}
	3499	{
	3500	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3501	result = (int)((wxGIFAnimation const *)arg1)->GetDelay(arg2);
	3502
	3503	wxPyEndAllowThreads(__tstate);
	3504	if (PyErr_Occurred()) SWIG_fail;
	3505	}
	3506	{
	3507	resultobj = SWIG_From_int((int)(result));
	3508	}
	3509	return resultobj;
	3510	fail:
	3511	return NULL;
	3512	}
	3513
	3514
	3515	static PyObject _wrap_GIFAnimation_GetLogicalScreenSize(PyObject , PyObject args, PyObject kwargs) {
	3516	PyObject *resultobj;
	3517	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3518	wxSize result;
	3519	PyObject * obj0 = 0 ;
	3520	char *kwnames[] = {
	3521	(char *) "self", NULL
	3522	};
	3523
	3524	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimation_GetLogicalScreenSize",kwnames,&obj0)) goto fail;
	3525	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3526	if (SWIG_arg_fail(1)) SWIG_fail;
	3527	{
	3528	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3529	result = ((wxGIFAnimation const *)arg1)->GetLogicalScreenSize();
	3530
	3531	wxPyEndAllowThreads(__tstate);
	3532	if (PyErr_Occurred()) SWIG_fail;
	3533	}
	3534	{
	3535	wxSize * resultptr;
	3536	resultptr = new wxSize((wxSize &)(result));
	3537	resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
	3538	}
	3539	return resultobj;
	3540	fail:
	3541	return NULL;
	3542	}
	3543
	3544
	3545	static PyObject _wrap_GIFAnimation_GetBackgroundColour(PyObject , PyObject args, PyObject kwargs) {
	3546	PyObject *resultobj;
	3547	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3548	wxColour *arg2 = 0 ;
	3549	bool result;
	3550	wxColour temp2 ;
	3551	PyObject * obj0 = 0 ;
	3552	PyObject * obj1 = 0 ;
	3553	char *kwnames[] = {
	3554	(char ) "self",(char ) "col", NULL
	3555	};
	3556
	3557	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
	3558	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3559	if (SWIG_arg_fail(1)) SWIG_fail;
	3560	{
	3561	arg2 = &temp2;
	3562	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3563	}
	3564	{
	3565	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3566	result = (bool)((wxGIFAnimation const )arg1)->GetBackgroundColour(arg2);
	3567
	3568	wxPyEndAllowThreads(__tstate);
	3569	if (PyErr_Occurred()) SWIG_fail;
	3570	}
	3571	{
	3572	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3573	}
	3574	return resultobj;
	3575	fail:
	3576	return NULL;
	3577	}
	3578
	3579
	3580	static PyObject _wrap_GIFAnimation_GetTransparentColour(PyObject , PyObject args, PyObject kwargs) {
	3581	PyObject *resultobj;
	3582	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3583	wxColour *arg2 = 0 ;
	3584	bool result;
	3585	wxColour temp2 ;
	3586	PyObject * obj0 = 0 ;
	3587	PyObject * obj1 = 0 ;
	3588	char *kwnames[] = {
	3589	(char ) "self",(char ) "col", NULL
	3590	};
	3591
	3592	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_GetTransparentColour",kwnames,&obj0,&obj1)) goto fail;
	3593	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3594	if (SWIG_arg_fail(1)) SWIG_fail;
	3595	{
	3596	arg2 = &temp2;
	3597	if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
	3598	}
	3599	{
	3600	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3601	result = (bool)((wxGIFAnimation const )arg1)->GetTransparentColour(arg2);
	3602
	3603	wxPyEndAllowThreads(__tstate);
	3604	if (PyErr_Occurred()) SWIG_fail;
	3605	}
	3606	{
	3607	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3608	}
	3609	return resultobj;
	3610	fail:
	3611	return NULL;
	3612	}
	3613
	3614
	3615	static PyObject _wrap_GIFAnimation_IsValid(PyObject , PyObject args, PyObject kwargs) {
	3616	PyObject *resultobj;
	3617	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3618	bool result;
	3619	PyObject * obj0 = 0 ;
	3620	char *kwnames[] = {
	3621	(char *) "self", NULL
	3622	};
	3623
	3624	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimation_IsValid",kwnames,&obj0)) goto fail;
	3625	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3626	if (SWIG_arg_fail(1)) SWIG_fail;
	3627	{
	3628	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3629	result = (bool)((wxGIFAnimation const *)arg1)->IsValid();
	3630
	3631	wxPyEndAllowThreads(__tstate);
	3632	if (PyErr_Occurred()) SWIG_fail;
	3633	}
	3634	{
	3635	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3636	}
	3637	return resultobj;
	3638	fail:
	3639	return NULL;
	3640	}
	3641
	3642
	3643	static PyObject _wrap_GIFAnimation_LoadFile(PyObject , PyObject args, PyObject kwargs) {
	3644	PyObject *resultobj;
	3645	wxGIFAnimation arg1 = (wxGIFAnimation ) 0 ;
	3646	wxString *arg2 = 0 ;
	3647	bool result;
	3648	bool temp2 = false ;
	3649	PyObject * obj0 = 0 ;
	3650	PyObject * obj1 = 0 ;
	3651	char *kwnames[] = {
	3652	(char ) "self",(char ) "filename", NULL
	3653	};
	3654
	3655	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimation_LoadFile",kwnames,&obj0,&obj1)) goto fail;
	3656	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimation, SWIG_POINTER_EXCEPTION \| 0);
	3657	if (SWIG_arg_fail(1)) SWIG_fail;
	3658	{
	3659	arg2 = wxString_in_helper(obj1);
	3660	if (arg2 == NULL) SWIG_fail;
	3661	temp2 = true;
	3662	}
	3663	{
	3664	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3665	result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
	3666
	3667	wxPyEndAllowThreads(__tstate);
	3668	if (PyErr_Occurred()) SWIG_fail;
	3669	}
	3670	{
	3671	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3672	}
	3673	{
	3674	if (temp2)
	3675	delete arg2;
	3676	}
	3677	return resultobj;
	3678	fail:
	3679	{
	3680	if (temp2)
	3681	delete arg2;
	3682	}
	3683	return NULL;
	3684	}
	3685
	3686
	3687	static PyObject * GIFAnimation_swigregister(PyObject , PyObject args) {
	3688	PyObject *obj;
	3689	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	3690	SWIG_TypeClientData(SWIGTYPE_p_wxGIFAnimation, obj);
	3691	Py_INCREF(obj);
	3692	return Py_BuildValue((char *)"");
	3693	}
	3694	static PyObject _wrap_new_GIFAnimationCtrl(PyObject , PyObject args, PyObject kwargs) {
	3695	PyObject *resultobj;
	3696	wxWindow arg1 = (wxWindow ) 0 ;
	3697	int arg2 = (int) -1 ;
	3698	wxString const &arg3_defvalue = wxPyEmptyString ;
	3699	wxString arg3 = (wxString ) &arg3_defvalue ;
	3700	wxPoint const &arg4_defvalue = wxDefaultPosition ;
	3701	wxPoint arg4 = (wxPoint ) &arg4_defvalue ;
	3702	wxSize const &arg5_defvalue = wxDefaultSize ;
	3703	wxSize arg5 = (wxSize ) &arg5_defvalue ;
	3704	long arg6 = (long) wxAN_FIT_ANIMATION\|wxNO_BORDER ;
	3705	wxString const &arg7_defvalue = wxPyAnimationControlNameStr ;
	3706	wxString arg7 = (wxString ) &arg7_defvalue ;
	3707	wxGIFAnimationCtrl *result;
	3708	bool temp3 = false ;
	3709	wxPoint temp4 ;
	3710	wxSize temp5 ;
	3711	bool temp7 = false ;
	3712	PyObject * obj0 = 0 ;
	3713	PyObject * obj1 = 0 ;
	3714	PyObject * obj2 = 0 ;
	3715	PyObject * obj3 = 0 ;
	3716	PyObject * obj4 = 0 ;
	3717	PyObject * obj5 = 0 ;
	3718	PyObject * obj6 = 0 ;
	3719	char *kwnames[] = {
	3720	(char ) "parent",(char ) "id",(char ) "filename",(char ) "pos",(char ) "size",(char ) "style",(char *) "name", NULL
	3721	};
	3722
	3723	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|OOOOOO:new_GIFAnimationCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
	3724	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	3725	if (SWIG_arg_fail(1)) SWIG_fail;
	3726	if (obj1) {
	3727	{
	3728	arg2 = (int)(SWIG_As_int(obj1));
	3729	if (SWIG_arg_fail(2)) SWIG_fail;
	3730	}
	3731	}
	3732	if (obj2) {
	3733	{
	3734	arg3 = wxString_in_helper(obj2);
	3735	if (arg3 == NULL) SWIG_fail;
	3736	temp3 = true;
	3737	}
	3738	}
	3739	if (obj3) {
	3740	{
	3741	arg4 = &temp4;
	3742	if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
	3743	}
	3744	}
	3745	if (obj4) {
	3746	{
	3747	arg5 = &temp5;
	3748	if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
	3749	}
	3750	}
	3751	if (obj5) {
	3752	{
	3753	arg6 = (long)(SWIG_As_long(obj5));
	3754	if (SWIG_arg_fail(6)) SWIG_fail;
	3755	}
	3756	}
	3757	if (obj6) {
	3758	{
	3759	arg7 = wxString_in_helper(obj6);
	3760	if (arg7 == NULL) SWIG_fail;
	3761	temp7 = true;
	3762	}
	3763	}
	3764	{
	3765	if (!wxPyCheckForApp()) SWIG_fail;
	3766	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3767	result = (wxGIFAnimationCtrl )new wxGIFAnimationCtrl(arg1,arg2,(wxString const &)arg3,(wxPoint const &)arg4,(wxSize const &)arg5,arg6,(wxString const &)*arg7);
	3768
	3769	wxPyEndAllowThreads(__tstate);
	3770	if (PyErr_Occurred()) SWIG_fail;
	3771	}
	3772	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFAnimationCtrl, 1);
	3773	{
	3774	if (temp3)
	3775	delete arg3;
	3776	}
	3777	{
	3778	if (temp7)
	3779	delete arg7;
	3780	}
	3781	return resultobj;
	3782	fail:
	3783	{
	3784	if (temp3)
	3785	delete arg3;
	3786	}
	3787	{
	3788	if (temp7)
	3789	delete arg7;
	3790	}
	3791	return NULL;
	3792	}
	3793
	3794
	3795	static PyObject _wrap_new_PreGIFAnimationCtrl(PyObject , PyObject args, PyObject kwargs) {
	3796	PyObject *resultobj;
	3797	wxGIFAnimationCtrl *result;
	3798	char *kwnames[] = {
	3799	NULL
	3800	};
	3801
	3802	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreGIFAnimationCtrl",kwnames)) goto fail;
	3803	{
	3804	if (!wxPyCheckForApp()) SWIG_fail;
	3805	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3806	result = (wxGIFAnimationCtrl *)new wxGIFAnimationCtrl();
	3807
	3808	wxPyEndAllowThreads(__tstate);
	3809	if (PyErr_Occurred()) SWIG_fail;
	3810	}
	3811	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFAnimationCtrl, 1);
	3812	return resultobj;
	3813	fail:
	3814	return NULL;
	3815	}
	3816
	3817
	3818	static PyObject _wrap_GIFAnimationCtrl_Create(PyObject , PyObject args, PyObject kwargs) {
	3819	PyObject *resultobj;
	3820	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	3821	wxWindow arg2 = (wxWindow ) 0 ;
	3822	int arg3 = (int) -1 ;
	3823	wxString const &arg4_defvalue = wxPyEmptyString ;
	3824	wxString arg4 = (wxString ) &arg4_defvalue ;
	3825	wxPoint const &arg5_defvalue = wxDefaultPosition ;
	3826	wxPoint arg5 = (wxPoint ) &arg5_defvalue ;
	3827	wxSize const &arg6_defvalue = wxDefaultSize ;
	3828	wxSize arg6 = (wxSize ) &arg6_defvalue ;
	3829	long arg7 = (long) wxAN_FIT_ANIMATION\|wxNO_BORDER ;
	3830	wxString const &arg8_defvalue = wxPyAnimationControlNameStr ;
	3831	wxString arg8 = (wxString ) &arg8_defvalue ;
	3832	bool result;
	3833	bool temp4 = false ;
	3834	wxPoint temp5 ;
	3835	wxSize temp6 ;
	3836	bool temp8 = false ;
	3837	PyObject * obj0 = 0 ;
	3838	PyObject * obj1 = 0 ;
	3839	PyObject * obj2 = 0 ;
	3840	PyObject * obj3 = 0 ;
	3841	PyObject * obj4 = 0 ;
	3842	PyObject * obj5 = 0 ;
	3843	PyObject * obj6 = 0 ;
	3844	PyObject * obj7 = 0 ;
	3845	char *kwnames[] = {
	3846	(char ) "self",(char ) "parent",(char ) "id",(char ) "filename",(char ) "pos",(char ) "size",(char ) "style",(char ) "name", NULL
	3847	};
	3848
	3849	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO\|OOOOOO:GIFAnimationCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
	3850	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	3851	if (SWIG_arg_fail(1)) SWIG_fail;
	3852	SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION \| 0);
	3853	if (SWIG_arg_fail(2)) SWIG_fail;
	3854	if (obj2) {
	3855	{
	3856	arg3 = (int)(SWIG_As_int(obj2));
	3857	if (SWIG_arg_fail(3)) SWIG_fail;
	3858	}
	3859	}
	3860	if (obj3) {
	3861	{
	3862	arg4 = wxString_in_helper(obj3);
	3863	if (arg4 == NULL) SWIG_fail;
	3864	temp4 = true;
	3865	}
	3866	}
	3867	if (obj4) {
	3868	{
	3869	arg5 = &temp5;
	3870	if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
	3871	}
	3872	}
	3873	if (obj5) {
	3874	{
	3875	arg6 = &temp6;
	3876	if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;
	3877	}
	3878	}
	3879	if (obj6) {
	3880	{
	3881	arg7 = (long)(SWIG_As_long(obj6));
	3882	if (SWIG_arg_fail(7)) SWIG_fail;
	3883	}
	3884	}
	3885	if (obj7) {
	3886	{
	3887	arg8 = wxString_in_helper(obj7);
	3888	if (arg8 == NULL) SWIG_fail;
	3889	temp8 = true;
	3890	}
	3891	}
	3892	{
	3893	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3894	result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)arg4,(wxPoint const &)arg5,(wxSize const &)arg6,arg7,(wxString const &)arg8);
	3895
	3896	wxPyEndAllowThreads(__tstate);
	3897	if (PyErr_Occurred()) SWIG_fail;
	3898	}
	3899	{
	3900	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3901	}
	3902	{
	3903	if (temp4)
	3904	delete arg4;
	3905	}
	3906	{
	3907	if (temp8)
	3908	delete arg8;
	3909	}
	3910	return resultobj;
	3911	fail:
	3912	{
	3913	if (temp4)
	3914	delete arg4;
	3915	}
	3916	{
	3917	if (temp8)
	3918	delete arg8;
	3919	}
	3920	return NULL;
	3921	}
	3922
	3923
	3924	static PyObject _wrap_GIFAnimationCtrl_LoadFile(PyObject , PyObject args, PyObject kwargs) {
	3925	PyObject *resultobj;
	3926	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	3927	wxString const &arg2_defvalue = wxPyEmptyString ;
	3928	wxString arg2 = (wxString ) &arg2_defvalue ;
	3929	bool result;
	3930	bool temp2 = false ;
	3931	PyObject * obj0 = 0 ;
	3932	PyObject * obj1 = 0 ;
	3933	char *kwnames[] = {
	3934	(char ) "self",(char ) "filename", NULL
	3935	};
	3936
	3937	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|O:GIFAnimationCtrl_LoadFile",kwnames,&obj0,&obj1)) goto fail;
	3938	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	3939	if (SWIG_arg_fail(1)) SWIG_fail;
	3940	if (obj1) {
	3941	{
	3942	arg2 = wxString_in_helper(obj1);
	3943	if (arg2 == NULL) SWIG_fail;
	3944	temp2 = true;
	3945	}
	3946	}
	3947	{
	3948	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3949	result = (bool)(arg1)->LoadFile((wxString const &)*arg2);
	3950
	3951	wxPyEndAllowThreads(__tstate);
	3952	if (PyErr_Occurred()) SWIG_fail;
	3953	}
	3954	{
	3955	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	3956	}
	3957	{
	3958	if (temp2)
	3959	delete arg2;
	3960	}
	3961	return resultobj;
	3962	fail:
	3963	{
	3964	if (temp2)
	3965	delete arg2;
	3966	}
	3967	return NULL;
	3968	}
	3969
	3970
	3971	static PyObject _wrap_GIFAnimationCtrl_Play(PyObject , PyObject args, PyObject kwargs) {
	3972	PyObject *resultobj;
	3973	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	3974	bool arg2 = (bool) true ;
	3975	bool result;
	3976	PyObject * obj0 = 0 ;
	3977	PyObject * obj1 = 0 ;
	3978	char *kwnames[] = {
	3979	(char ) "self",(char ) "looped", NULL
	3980	};
	3981
	3982	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|O:GIFAnimationCtrl_Play",kwnames,&obj0,&obj1)) goto fail;
	3983	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	3984	if (SWIG_arg_fail(1)) SWIG_fail;
	3985	if (obj1) {
	3986	{
	3987	arg2 = (bool)(SWIG_As_bool(obj1));
	3988	if (SWIG_arg_fail(2)) SWIG_fail;
	3989	}
	3990	}
	3991	{
	3992	PyThreadState* __tstate = wxPyBeginAllowThreads();
	3993	result = (bool)(arg1)->Play(arg2);
	3994
	3995	wxPyEndAllowThreads(__tstate);
	3996	if (PyErr_Occurred()) SWIG_fail;
	3997	}
	3998	{
	3999	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	4000	}
	4001	return resultobj;
	4002	fail:
	4003	return NULL;
	4004	}
	4005
	4006
	4007	static PyObject _wrap_GIFAnimationCtrl_Stop(PyObject , PyObject args, PyObject kwargs) {
	4008	PyObject *resultobj;
	4009	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4010	PyObject * obj0 = 0 ;
	4011	char *kwnames[] = {
	4012	(char *) "self", NULL
	4013	};
	4014
	4015	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_Stop",kwnames,&obj0)) goto fail;
	4016	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4017	if (SWIG_arg_fail(1)) SWIG_fail;
	4018	{
	4019	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4020	(arg1)->Stop();
	4021
	4022	wxPyEndAllowThreads(__tstate);
	4023	if (PyErr_Occurred()) SWIG_fail;
	4024	}
	4025	Py_INCREF(Py_None); resultobj = Py_None;
	4026	return resultobj;
	4027	fail:
	4028	return NULL;
	4029	}
	4030
	4031
	4032	static PyObject _wrap_GIFAnimationCtrl_FitToAnimation(PyObject , PyObject args, PyObject kwargs) {
	4033	PyObject *resultobj;
	4034	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4035	PyObject * obj0 = 0 ;
	4036	char *kwnames[] = {
	4037	(char *) "self", NULL
	4038	};
	4039
	4040	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_FitToAnimation",kwnames,&obj0)) goto fail;
	4041	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4042	if (SWIG_arg_fail(1)) SWIG_fail;
	4043	{
	4044	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4045	(arg1)->FitToAnimation();
	4046
	4047	wxPyEndAllowThreads(__tstate);
	4048	if (PyErr_Occurred()) SWIG_fail;
	4049	}
	4050	Py_INCREF(Py_None); resultobj = Py_None;
	4051	return resultobj;
	4052	fail:
	4053	return NULL;
	4054	}
	4055
	4056
	4057	static PyObject _wrap_GIFAnimationCtrl_IsPlaying(PyObject , PyObject args, PyObject kwargs) {
	4058	PyObject *resultobj;
	4059	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4060	bool result;
	4061	PyObject * obj0 = 0 ;
	4062	char *kwnames[] = {
	4063	(char *) "self", NULL
	4064	};
	4065
	4066	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_IsPlaying",kwnames,&obj0)) goto fail;
	4067	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4068	if (SWIG_arg_fail(1)) SWIG_fail;
	4069	{
	4070	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4071	result = (bool)((wxGIFAnimationCtrl const *)arg1)->IsPlaying();
	4072
	4073	wxPyEndAllowThreads(__tstate);
	4074	if (PyErr_Occurred()) SWIG_fail;
	4075	}
	4076	{
	4077	resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
	4078	}
	4079	return resultobj;
	4080	fail:
	4081	return NULL;
	4082	}
	4083
	4084
	4085	static PyObject _wrap_GIFAnimationCtrl_GetPlayer(PyObject , PyObject args, PyObject kwargs) {
	4086	PyObject *resultobj;
	4087	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4088	wxAnimationPlayer *result;
	4089	PyObject * obj0 = 0 ;
	4090	char *kwnames[] = {
	4091	(char *) "self", NULL
	4092	};
	4093
	4094	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_GetPlayer",kwnames,&obj0)) goto fail;
	4095	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4096	if (SWIG_arg_fail(1)) SWIG_fail;
	4097	{
	4098	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4099	{
	4100	wxAnimationPlayer &_result_ref = (arg1)->GetPlayer();
	4101	result = (wxAnimationPlayer *) &_result_ref;
	4102	}
	4103
	4104	wxPyEndAllowThreads(__tstate);
	4105	if (PyErr_Occurred()) SWIG_fail;
	4106	}
	4107	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAnimationPlayer, 0);
	4108	return resultobj;
	4109	fail:
	4110	return NULL;
	4111	}
	4112
	4113
	4114	static PyObject _wrap_GIFAnimationCtrl_GetAnimation(PyObject , PyObject args, PyObject kwargs) {
	4115	PyObject *resultobj;
	4116	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4117	wxAnimationBase *result;
	4118	PyObject * obj0 = 0 ;
	4119	char *kwnames[] = {
	4120	(char *) "self", NULL
	4121	};
	4122
	4123	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_GetAnimation",kwnames,&obj0)) goto fail;
	4124	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4125	if (SWIG_arg_fail(1)) SWIG_fail;
	4126	{
	4127	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4128	result = (wxAnimationBase *)(arg1)->GetAnimation();
	4129
	4130	wxPyEndAllowThreads(__tstate);
	4131	if (PyErr_Occurred()) SWIG_fail;
	4132	}
	4133	resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAnimationBase, 0);
	4134	return resultobj;
	4135	fail:
	4136	return NULL;
	4137	}
	4138
	4139
	4140	static PyObject _wrap_GIFAnimationCtrl_GetFilename(PyObject , PyObject args, PyObject kwargs) {
	4141	PyObject *resultobj;
	4142	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4143	wxString *result;
	4144	PyObject * obj0 = 0 ;
	4145	char *kwnames[] = {
	4146	(char *) "self", NULL
	4147	};
	4148
	4149	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GIFAnimationCtrl_GetFilename",kwnames,&obj0)) goto fail;
	4150	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4151	if (SWIG_arg_fail(1)) SWIG_fail;
	4152	{
	4153	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4154	{
	4155	wxString const &_result_ref = ((wxGIFAnimationCtrl const *)arg1)->GetFilename();
	4156	result = (wxString *) &_result_ref;
	4157	}
	4158
	4159	wxPyEndAllowThreads(__tstate);
	4160	if (PyErr_Occurred()) SWIG_fail;
	4161	}
	4162	{
	4163	#if wxUSE_UNICODE
	4164	resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
	4165	#else
	4166	resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
	4167	#endif
	4168	}
	4169	return resultobj;
	4170	fail:
	4171	return NULL;
	4172	}
	4173
	4174
	4175	static PyObject _wrap_GIFAnimationCtrl_SetFilename(PyObject , PyObject args, PyObject kwargs) {
	4176	PyObject *resultobj;
	4177	wxGIFAnimationCtrl arg1 = (wxGIFAnimationCtrl ) 0 ;
	4178	wxString *arg2 = 0 ;
	4179	bool temp2 = false ;
	4180	PyObject * obj0 = 0 ;
	4181	PyObject * obj1 = 0 ;
	4182	char *kwnames[] = {
	4183	(char ) "self",(char ) "filename", NULL
	4184	};
	4185
	4186	if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GIFAnimationCtrl_SetFilename",kwnames,&obj0,&obj1)) goto fail;
	4187	SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGIFAnimationCtrl, SWIG_POINTER_EXCEPTION \| 0);
	4188	if (SWIG_arg_fail(1)) SWIG_fail;
	4189	{
	4190	arg2 = wxString_in_helper(obj1);
	4191	if (arg2 == NULL) SWIG_fail;
	4192	temp2 = true;
	4193	}
	4194	{
	4195	PyThreadState* __tstate = wxPyBeginAllowThreads();
	4196	(arg1)->SetFilename((wxString const &)*arg2);
	4197
	4198	wxPyEndAllowThreads(__tstate);
	4199	if (PyErr_Occurred()) SWIG_fail;
	4200	}
	4201	Py_INCREF(Py_None); resultobj = Py_None;
	4202	{
	4203	if (temp2)
	4204	delete arg2;
	4205	}
	4206	return resultobj;
	4207	fail:
	4208	{
	4209	if (temp2)
	4210	delete arg2;
	4211	}
	4212	return NULL;
	4213	}
	4214
	4215
	4216	static PyObject * GIFAnimationCtrl_swigregister(PyObject , PyObject args) {
	4217	PyObject *obj;
	4218	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
	4219	SWIG_TypeClientData(SWIGTYPE_p_wxGIFAnimationCtrl, obj);
	4220	Py_INCREF(obj);
	4221	return Py_BuildValue((char *)"");
	4222	}
	4223	static PyMethodDef SwigMethods[] = {
	4224	{ (char *)"new_AnimationPlayer", (PyCFunction) _wrap_new_AnimationPlayer, METH_VARARGS \| METH_KEYWORDS, NULL},
	4225	{ (char *)"delete_AnimationPlayer", (PyCFunction) _wrap_delete_AnimationPlayer, METH_VARARGS \| METH_KEYWORDS, NULL},
	4226	{ (char *)"AnimationPlayer_SetAnimation", (PyCFunction) _wrap_AnimationPlayer_SetAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4227	{ (char *)"AnimationPlayer_GetAnimation", (PyCFunction) _wrap_AnimationPlayer_GetAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4228	{ (char *)"AnimationPlayer_SetDestroyAnimation", (PyCFunction) _wrap_AnimationPlayer_SetDestroyAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4229	{ (char *)"AnimationPlayer_GetDestroyAnimation", (PyCFunction) _wrap_AnimationPlayer_GetDestroyAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4230	{ (char *)"AnimationPlayer_SetCurrentFrame", (PyCFunction) _wrap_AnimationPlayer_SetCurrentFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4231	{ (char *)"AnimationPlayer_GetCurrentFrame", (PyCFunction) _wrap_AnimationPlayer_GetCurrentFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4232	{ (char *)"AnimationPlayer_SetWindow", (PyCFunction) _wrap_AnimationPlayer_SetWindow, METH_VARARGS \| METH_KEYWORDS, NULL},
	4233	{ (char *)"AnimationPlayer_GetWindow", (PyCFunction) _wrap_AnimationPlayer_GetWindow, METH_VARARGS \| METH_KEYWORDS, NULL},
	4234	{ (char *)"AnimationPlayer_SetPosition", (PyCFunction) _wrap_AnimationPlayer_SetPosition, METH_VARARGS \| METH_KEYWORDS, NULL},
	4235	{ (char *)"AnimationPlayer_GetPosition", (PyCFunction) _wrap_AnimationPlayer_GetPosition, METH_VARARGS \| METH_KEYWORDS, NULL},
	4236	{ (char *)"AnimationPlayer_SetLooped", (PyCFunction) _wrap_AnimationPlayer_SetLooped, METH_VARARGS \| METH_KEYWORDS, NULL},
	4237	{ (char *)"AnimationPlayer_GetLooped", (PyCFunction) _wrap_AnimationPlayer_GetLooped, METH_VARARGS \| METH_KEYWORDS, NULL},
	4238	{ (char *)"AnimationPlayer_HasAnimation", (PyCFunction) _wrap_AnimationPlayer_HasAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4239	{ (char *)"AnimationPlayer_IsPlaying", (PyCFunction) _wrap_AnimationPlayer_IsPlaying, METH_VARARGS \| METH_KEYWORDS, NULL},
	4240	{ (char *)"AnimationPlayer_UseBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_UseBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4241	{ (char *)"AnimationPlayer_UsingBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_UsingBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4242	{ (char *)"AnimationPlayer_SetCustomBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_SetCustomBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4243	{ (char *)"AnimationPlayer_UsingCustomBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_UsingCustomBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4244	{ (char *)"AnimationPlayer_GetCustomBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_GetCustomBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4245	{ (char *)"AnimationPlayer_UseParentBackground", (PyCFunction) _wrap_AnimationPlayer_UseParentBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4246	{ (char *)"AnimationPlayer_UsingParentBackground", (PyCFunction) _wrap_AnimationPlayer_UsingParentBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4247	{ (char *)"AnimationPlayer_Play", (PyCFunction) _wrap_AnimationPlayer_Play, METH_VARARGS \| METH_KEYWORDS, NULL},
	4248	{ (char *)"AnimationPlayer_Build", (PyCFunction) _wrap_AnimationPlayer_Build, METH_VARARGS \| METH_KEYWORDS, NULL},
	4249	{ (char *)"AnimationPlayer_Stop", (PyCFunction) _wrap_AnimationPlayer_Stop, METH_VARARGS \| METH_KEYWORDS, NULL},
	4250	{ (char *)"AnimationPlayer_Draw", (PyCFunction) _wrap_AnimationPlayer_Draw, METH_VARARGS \| METH_KEYWORDS, NULL},
	4251	{ (char *)"AnimationPlayer_GetFrameCount", (PyCFunction) _wrap_AnimationPlayer_GetFrameCount, METH_VARARGS \| METH_KEYWORDS, NULL},
	4252	{ (char *)"AnimationPlayer_GetFrame", (PyCFunction) _wrap_AnimationPlayer_GetFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4253	{ (char *)"AnimationPlayer_GetDisposalMethod", (PyCFunction) _wrap_AnimationPlayer_GetDisposalMethod, METH_VARARGS \| METH_KEYWORDS, NULL},
	4254	{ (char *)"AnimationPlayer_GetFrameRect", (PyCFunction) _wrap_AnimationPlayer_GetFrameRect, METH_VARARGS \| METH_KEYWORDS, NULL},
	4255	{ (char *)"AnimationPlayer_GetDelay", (PyCFunction) _wrap_AnimationPlayer_GetDelay, METH_VARARGS \| METH_KEYWORDS, NULL},
	4256	{ (char *)"AnimationPlayer_GetLogicalScreenSize", (PyCFunction) _wrap_AnimationPlayer_GetLogicalScreenSize, METH_VARARGS \| METH_KEYWORDS, NULL},
	4257	{ (char *)"AnimationPlayer_GetBackgroundColour", (PyCFunction) _wrap_AnimationPlayer_GetBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4258	{ (char *)"AnimationPlayer_GetTransparentColour", (PyCFunction) _wrap_AnimationPlayer_GetTransparentColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4259	{ (char *)"AnimationPlayer_PlayFrame", (PyCFunction) _wrap_AnimationPlayer_PlayFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4260	{ (char *)"AnimationPlayer_PlayNextFrame", (PyCFunction) _wrap_AnimationPlayer_PlayNextFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4261	{ (char *)"AnimationPlayer_DrawFrame", (PyCFunction) _wrap_AnimationPlayer_DrawFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4262	{ (char *)"AnimationPlayer_DrawBackground", (PyCFunction) _wrap_AnimationPlayer_DrawBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4263	{ (char *)"AnimationPlayer_ClearCache", (PyCFunction) _wrap_AnimationPlayer_ClearCache, METH_VARARGS \| METH_KEYWORDS, NULL},
	4264	{ (char *)"AnimationPlayer_SaveBackground", (PyCFunction) _wrap_AnimationPlayer_SaveBackground, METH_VARARGS \| METH_KEYWORDS, NULL},
	4265	{ (char *)"AnimationPlayer_GetBackingStore", (PyCFunction) _wrap_AnimationPlayer_GetBackingStore, METH_VARARGS \| METH_KEYWORDS, NULL},
	4266	{ (char *)"AnimationPlayer_swigregister", AnimationPlayer_swigregister, METH_VARARGS, NULL},
	4267	{ (char *)"delete_AnimationBase", (PyCFunction) _wrap_delete_AnimationBase, METH_VARARGS \| METH_KEYWORDS, NULL},
	4268	{ (char *)"AnimationBase_GetFrameCount", (PyCFunction) _wrap_AnimationBase_GetFrameCount, METH_VARARGS \| METH_KEYWORDS, NULL},
	4269	{ (char *)"AnimationBase_GetFrame", (PyCFunction) _wrap_AnimationBase_GetFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4270	{ (char *)"AnimationBase_GetDisposalMethod", (PyCFunction) _wrap_AnimationBase_GetDisposalMethod, METH_VARARGS \| METH_KEYWORDS, NULL},
	4271	{ (char *)"AnimationBase_GetFrameRect", (PyCFunction) _wrap_AnimationBase_GetFrameRect, METH_VARARGS \| METH_KEYWORDS, NULL},
	4272	{ (char *)"AnimationBase_GetDelay", (PyCFunction) _wrap_AnimationBase_GetDelay, METH_VARARGS \| METH_KEYWORDS, NULL},
	4273	{ (char *)"AnimationBase_GetLogicalScreenSize", (PyCFunction) _wrap_AnimationBase_GetLogicalScreenSize, METH_VARARGS \| METH_KEYWORDS, NULL},
	4274	{ (char *)"AnimationBase_GetBackgroundColour", (PyCFunction) _wrap_AnimationBase_GetBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4275	{ (char *)"AnimationBase_GetTransparentColour", (PyCFunction) _wrap_AnimationBase_GetTransparentColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4276	{ (char *)"AnimationBase_IsValid", (PyCFunction) _wrap_AnimationBase_IsValid, METH_VARARGS \| METH_KEYWORDS, NULL},
	4277	{ (char *)"AnimationBase_LoadFile", (PyCFunction) _wrap_AnimationBase_LoadFile, METH_VARARGS \| METH_KEYWORDS, NULL},
	4278	{ (char *)"AnimationBase_swigregister", AnimationBase_swigregister, METH_VARARGS, NULL},
	4279	{ (char *)"new_GIFAnimation", (PyCFunction) _wrap_new_GIFAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4280	{ (char *)"delete_GIFAnimation", (PyCFunction) _wrap_delete_GIFAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4281	{ (char *)"GIFAnimation_GetFrameCount", (PyCFunction) _wrap_GIFAnimation_GetFrameCount, METH_VARARGS \| METH_KEYWORDS, NULL},
	4282	{ (char *)"GIFAnimation_GetFrame", (PyCFunction) _wrap_GIFAnimation_GetFrame, METH_VARARGS \| METH_KEYWORDS, NULL},
	4283	{ (char *)"GIFAnimation_GetDisposalMethod", (PyCFunction) _wrap_GIFAnimation_GetDisposalMethod, METH_VARARGS \| METH_KEYWORDS, NULL},
	4284	{ (char *)"GIFAnimation_GetFrameRect", (PyCFunction) _wrap_GIFAnimation_GetFrameRect, METH_VARARGS \| METH_KEYWORDS, NULL},
	4285	{ (char *)"GIFAnimation_GetDelay", (PyCFunction) _wrap_GIFAnimation_GetDelay, METH_VARARGS \| METH_KEYWORDS, NULL},
	4286	{ (char *)"GIFAnimation_GetLogicalScreenSize", (PyCFunction) _wrap_GIFAnimation_GetLogicalScreenSize, METH_VARARGS \| METH_KEYWORDS, NULL},
	4287	{ (char *)"GIFAnimation_GetBackgroundColour", (PyCFunction) _wrap_GIFAnimation_GetBackgroundColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4288	{ (char *)"GIFAnimation_GetTransparentColour", (PyCFunction) _wrap_GIFAnimation_GetTransparentColour, METH_VARARGS \| METH_KEYWORDS, NULL},
	4289	{ (char *)"GIFAnimation_IsValid", (PyCFunction) _wrap_GIFAnimation_IsValid, METH_VARARGS \| METH_KEYWORDS, NULL},
	4290	{ (char *)"GIFAnimation_LoadFile", (PyCFunction) _wrap_GIFAnimation_LoadFile, METH_VARARGS \| METH_KEYWORDS, NULL},
	4291	{ (char *)"GIFAnimation_swigregister", GIFAnimation_swigregister, METH_VARARGS, NULL},
	4292	{ (char *)"new_GIFAnimationCtrl", (PyCFunction) _wrap_new_GIFAnimationCtrl, METH_VARARGS \| METH_KEYWORDS, NULL},
	4293	{ (char *)"new_PreGIFAnimationCtrl", (PyCFunction) _wrap_new_PreGIFAnimationCtrl, METH_VARARGS \| METH_KEYWORDS, NULL},
	4294	{ (char *)"GIFAnimationCtrl_Create", (PyCFunction) _wrap_GIFAnimationCtrl_Create, METH_VARARGS \| METH_KEYWORDS, NULL},
	4295	{ (char *)"GIFAnimationCtrl_LoadFile", (PyCFunction) _wrap_GIFAnimationCtrl_LoadFile, METH_VARARGS \| METH_KEYWORDS, NULL},
	4296	{ (char *)"GIFAnimationCtrl_Play", (PyCFunction) _wrap_GIFAnimationCtrl_Play, METH_VARARGS \| METH_KEYWORDS, NULL},
	4297	{ (char *)"GIFAnimationCtrl_Stop", (PyCFunction) _wrap_GIFAnimationCtrl_Stop, METH_VARARGS \| METH_KEYWORDS, NULL},
	4298	{ (char *)"GIFAnimationCtrl_FitToAnimation", (PyCFunction) _wrap_GIFAnimationCtrl_FitToAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4299	{ (char *)"GIFAnimationCtrl_IsPlaying", (PyCFunction) _wrap_GIFAnimationCtrl_IsPlaying, METH_VARARGS \| METH_KEYWORDS, NULL},
	4300	{ (char *)"GIFAnimationCtrl_GetPlayer", (PyCFunction) _wrap_GIFAnimationCtrl_GetPlayer, METH_VARARGS \| METH_KEYWORDS, NULL},
	4301	{ (char *)"GIFAnimationCtrl_GetAnimation", (PyCFunction) _wrap_GIFAnimationCtrl_GetAnimation, METH_VARARGS \| METH_KEYWORDS, NULL},
	4302	{ (char *)"GIFAnimationCtrl_GetFilename", (PyCFunction) _wrap_GIFAnimationCtrl_GetFilename, METH_VARARGS \| METH_KEYWORDS, NULL},
	4303	{ (char *)"GIFAnimationCtrl_SetFilename", (PyCFunction) _wrap_GIFAnimationCtrl_SetFilename, METH_VARARGS \| METH_KEYWORDS, NULL},
	4304	{ (char *)"GIFAnimationCtrl_swigregister", GIFAnimationCtrl_swigregister, METH_VARARGS, NULL},
	4305	{ NULL, NULL, 0, NULL }
	4306	};
	4307
	4308
	4309	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
	4310
	4311	static void _p_wxLayoutConstraintsTo_p_wxObject(void x) {
	4312	return (void )((wxObject ) ((wxLayoutConstraints *) x));
	4313	}
	4314	static void _p_wxGBSizerItemTo_p_wxObject(void x) {
	4315	return (void )((wxObject ) (wxSizerItem ) ((wxGBSizerItem ) x));
	4316	}
	4317	static void _p_wxSizerItemTo_p_wxObject(void x) {
	4318	return (void )((wxObject ) ((wxSizerItem *) x));
	4319	}
	4320	static void _p_wxScrollEventTo_p_wxObject(void x) {
	4321	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxScrollEvent *) x));
	4322	}
	4323	static void _p_wxIndividualLayoutConstraintTo_p_wxObject(void x) {
	4324	return (void )((wxObject ) ((wxIndividualLayoutConstraint *) x));
	4325	}
	4326	static void _p_wxStaticBoxSizerTo_p_wxObject(void x) {
	4327	return (void )((wxObject ) (wxSizer )(wxBoxSizer ) ((wxStaticBoxSizer *) x));
	4328	}
	4329	static void _p_wxBoxSizerTo_p_wxObject(void x) {
	4330	return (void )((wxObject ) (wxSizer ) ((wxBoxSizer ) x));
	4331	}
	4332	static void _p_wxSizerTo_p_wxObject(void x) {
	4333	return (void )((wxObject ) ((wxSizer *) x));
	4334	}
	4335	static void _p_wxGridBagSizerTo_p_wxObject(void x) {
	4336	return (void )((wxObject ) (wxSizer )(wxGridSizer )(wxFlexGridSizer ) ((wxGridBagSizer ) x));
	4337	}
	4338	static void _p_wxUpdateUIEventTo_p_wxObject(void x) {
	4339	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxUpdateUIEvent *) x));
	4340	}
	4341	static void _p_wxEventTo_p_wxObject(void x) {
	4342	return (void )((wxObject ) ((wxEvent *) x));
	4343	}
	4344	static void _p_wxFlexGridSizerTo_p_wxObject(void x) {
	4345	return (void )((wxObject ) (wxSizer )(wxGridSizer ) ((wxFlexGridSizer *) x));
	4346	}
	4347	static void _p_wxGridSizerTo_p_wxObject(void x) {
	4348	return (void )((wxObject ) (wxSizer ) ((wxGridSizer ) x));
	4349	}
	4350	static void _p_wxInitDialogEventTo_p_wxObject(void x) {
	4351	return (void )((wxObject ) (wxEvent ) ((wxInitDialogEvent ) x));
	4352	}
	4353	static void _p_wxAnimationBaseTo_p_wxObject(void x) {
	4354	return (void )((wxObject ) ((wxAnimationBase *) x));
	4355	}
	4356	static void _p_wxPaintEventTo_p_wxObject(void x) {
	4357	return (void )((wxObject ) (wxEvent ) ((wxPaintEvent ) x));
	4358	}
	4359	static void _p_wxNcPaintEventTo_p_wxObject(void x) {
	4360	return (void )((wxObject ) (wxEvent ) ((wxNcPaintEvent ) x));
	4361	}
	4362	static void _p_wxPaletteChangedEventTo_p_wxObject(void x) {
	4363	return (void )((wxObject ) (wxEvent ) ((wxPaletteChangedEvent ) x));
	4364	}
	4365	static void _p_wxDisplayChangedEventTo_p_wxObject(void x) {
	4366	return (void )((wxObject ) (wxEvent ) ((wxDisplayChangedEvent ) x));
	4367	}
	4368	static void _p_wxMouseCaptureChangedEventTo_p_wxObject(void x) {
	4369	return (void )((wxObject ) (wxEvent ) ((wxMouseCaptureChangedEvent ) x));
	4370	}
	4371	static void _p_wxSysColourChangedEventTo_p_wxObject(void x) {
	4372	return (void )((wxObject ) (wxEvent ) ((wxSysColourChangedEvent ) x));
	4373	}
	4374	static void _p_wxControlTo_p_wxObject(void x) {
	4375	return (void )((wxObject ) (wxEvtHandler )(wxWindow ) ((wxControl *) x));
	4376	}
	4377	static void _p_wxSetCursorEventTo_p_wxObject(void x) {
	4378	return (void )((wxObject ) (wxEvent ) ((wxSetCursorEvent ) x));
	4379	}
	4380	static void _p_wxFSFileTo_p_wxObject(void x) {
	4381	return (void )((wxObject ) ((wxFSFile *) x));
	4382	}
	4383	static void _p_wxPySizerTo_p_wxObject(void x) {
	4384	return (void )((wxObject ) (wxSizer ) ((wxPySizer ) x));
	4385	}
	4386	static void _p_wxPyEventTo_p_wxObject(void x) {
	4387	return (void )((wxObject ) (wxEvent ) ((wxPyEvent ) x));
	4388	}
	4389	static void _p_wxNotifyEventTo_p_wxObject(void x) {
	4390	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxNotifyEvent *) x));
	4391	}
	4392	static void _p_wxShowEventTo_p_wxObject(void x) {
	4393	return (void )((wxObject ) (wxEvent ) ((wxShowEvent ) x));
	4394	}
	4395	static void _p_wxAnimationPlayerTo_p_wxObject(void x) {
	4396	return (void )((wxObject ) ((wxAnimationPlayer *) x));
	4397	}
	4398	static void _p_wxMenuItemTo_p_wxObject(void x) {
	4399	return (void )((wxObject ) ((wxMenuItem *) x));
	4400	}
	4401	static void _p_wxDateEventTo_p_wxObject(void x) {
	4402	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxDateEvent *) x));
	4403	}
	4404	static void _p_wxIdleEventTo_p_wxObject(void x) {
	4405	return (void )((wxObject ) (wxEvent ) ((wxIdleEvent ) x));
	4406	}
	4407	static void _p_wxWindowCreateEventTo_p_wxObject(void x) {
	4408	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxWindowCreateEvent *) x));
	4409	}
	4410	static void _p_wxQueryNewPaletteEventTo_p_wxObject(void x) {
	4411	return (void )((wxObject ) (wxEvent ) ((wxQueryNewPaletteEvent ) x));
	4412	}
	4413	static void _p_wxMaximizeEventTo_p_wxObject(void x) {
	4414	return (void )((wxObject ) (wxEvent ) ((wxMaximizeEvent ) x));
	4415	}
	4416	static void _p_wxIconizeEventTo_p_wxObject(void x) {
	4417	return (void )((wxObject ) (wxEvent ) ((wxIconizeEvent ) x));
	4418	}
	4419	static void _p_wxSizeEventTo_p_wxObject(void x) {
	4420	return (void )((wxObject ) (wxEvent ) ((wxSizeEvent ) x));
	4421	}
	4422	static void _p_wxMoveEventTo_p_wxObject(void x) {
	4423	return (void )((wxObject ) (wxEvent ) ((wxMoveEvent ) x));
	4424	}
	4425	static void _p_wxActivateEventTo_p_wxObject(void x) {
	4426	return (void )((wxObject ) (wxEvent ) ((wxActivateEvent ) x));
	4427	}
	4428	static void _p_wxXPMHandlerTo_p_wxObject(void x) {
	4429	return (void )((wxObject ) (wxImageHandler ) ((wxXPMHandler ) x));
	4430	}
	4431	static void _p_wxPNMHandlerTo_p_wxObject(void x) {
	4432	return (void )((wxObject ) (wxImageHandler ) ((wxPNMHandler ) x));
	4433	}
	4434	static void _p_wxJPEGHandlerTo_p_wxObject(void x) {
	4435	return (void )((wxObject ) (wxImageHandler ) ((wxJPEGHandler ) x));
	4436	}
	4437	static void _p_wxPCXHandlerTo_p_wxObject(void x) {
	4438	return (void )((wxObject ) (wxImageHandler ) ((wxPCXHandler ) x));
	4439	}
	4440	static void _p_wxGIFHandlerTo_p_wxObject(void x) {
	4441	return (void )((wxObject ) (wxImageHandler ) ((wxGIFHandler ) x));
	4442	}
	4443	static void _p_wxPNGHandlerTo_p_wxObject(void x) {
	4444	return (void )((wxObject ) (wxImageHandler ) ((wxPNGHandler ) x));
	4445	}
	4446	static void _p_wxANIHandlerTo_p_wxObject(void x) {
	4447	return (void )((wxObject ) (wxImageHandler )(wxBMPHandler )(wxICOHandler )(wxCURHandler ) ((wxANIHandler *) x));
	4448	}
	4449	static void _p_wxCURHandlerTo_p_wxObject(void x) {
	4450	return (void )((wxObject ) (wxImageHandler )(wxBMPHandler )(wxICOHandler ) ((wxCURHandler ) x));
	4451	}
	4452	static void _p_wxICOHandlerTo_p_wxObject(void x) {
	4453	return (void )((wxObject ) (wxImageHandler )(wxBMPHandler ) ((wxICOHandler *) x));
	4454	}
	4455	static void _p_wxBMPHandlerTo_p_wxObject(void x) {
	4456	return (void )((wxObject ) (wxImageHandler ) ((wxBMPHandler ) x));
	4457	}
	4458	static void _p_wxImageHandlerTo_p_wxObject(void x) {
	4459	return (void )((wxObject ) ((wxImageHandler *) x));
	4460	}
	4461	static void _p_wxTIFFHandlerTo_p_wxObject(void x) {
	4462	return (void )((wxObject ) (wxImageHandler ) ((wxTIFFHandler ) x));
	4463	}
	4464	static void _p_wxEvtHandlerTo_p_wxObject(void x) {
	4465	return (void )((wxObject ) ((wxEvtHandler *) x));
	4466	}
	4467	static void _p_wxStdDialogButtonSizerTo_p_wxObject(void x) {
	4468	return (void )((wxObject ) (wxSizer )(wxBoxSizer ) ((wxStdDialogButtonSizer *) x));
	4469	}
	4470	static void _p_wxAcceleratorTableTo_p_wxObject(void x) {
	4471	return (void )((wxObject ) ((wxAcceleratorTable *) x));
	4472	}
	4473	static void _p_wxImageTo_p_wxObject(void x) {
	4474	return (void )((wxObject ) ((wxImage *) x));
	4475	}
	4476	static void _p_wxScrollWinEventTo_p_wxObject(void x) {
	4477	return (void )((wxObject ) (wxEvent ) ((wxScrollWinEvent ) x));
	4478	}
	4479	static void _p_wxWindowDestroyEventTo_p_wxObject(void x) {
	4480	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxWindowDestroyEvent *) x));
	4481	}
	4482	static void _p_wxNavigationKeyEventTo_p_wxObject(void x) {
	4483	return (void )((wxObject ) (wxEvent ) ((wxNavigationKeyEvent ) x));
	4484	}
	4485	static void _p_wxKeyEventTo_p_wxObject(void x) {
	4486	return (void )((wxObject ) (wxEvent ) ((wxKeyEvent ) x));
	4487	}
	4488	static void _p_wxWindowTo_p_wxObject(void x) {
	4489	return (void )((wxObject ) (wxEvtHandler ) ((wxWindow ) x));
	4490	}
	4491	static void _p_wxMenuTo_p_wxObject(void x) {
	4492	return (void )((wxObject ) (wxEvtHandler ) ((wxMenu ) x));
	4493	}
	4494	static void _p_wxMenuBarTo_p_wxObject(void x) {
	4495	return (void )((wxObject ) (wxEvtHandler )(wxWindow ) ((wxMenuBar *) x));
	4496	}
	4497	static void _p_wxFileSystemTo_p_wxObject(void x) {
	4498	return (void )((wxObject ) ((wxFileSystem *) x));
	4499	}
	4500	static void _p_wxGIFAnimationTo_p_wxObject(void x) {
	4501	return (void )((wxObject ) (wxAnimationBase ) ((wxGIFAnimation ) x));
	4502	}
	4503	static void _p_wxContextMenuEventTo_p_wxObject(void x) {
	4504	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxContextMenuEvent *) x));
	4505	}
	4506	static void _p_wxMenuEventTo_p_wxObject(void x) {
	4507	return (void )((wxObject ) (wxEvent ) ((wxMenuEvent ) x));
	4508	}
	4509	static void _p_wxPyAppTo_p_wxObject(void x) {
	4510	return (void )((wxObject ) (wxEvtHandler ) ((wxPyApp ) x));
	4511	}
	4512	static void _p_wxCloseEventTo_p_wxObject(void x) {
	4513	return (void )((wxObject ) (wxEvent ) ((wxCloseEvent ) x));
	4514	}
	4515	static void _p_wxMouseEventTo_p_wxObject(void x) {
	4516	return (void )((wxObject ) (wxEvent ) ((wxMouseEvent ) x));
	4517	}
	4518	static void _p_wxEraseEventTo_p_wxObject(void x) {
	4519	return (void )((wxObject ) (wxEvent ) ((wxEraseEvent ) x));
	4520	}
	4521	static void _p_wxPyCommandEventTo_p_wxObject(void x) {
	4522	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxPyCommandEvent *) x));
	4523	}
	4524	static void _p_wxCommandEventTo_p_wxObject(void x) {
	4525	return (void )((wxObject ) (wxEvent ) ((wxCommandEvent ) x));
	4526	}
	4527	static void _p_wxDropFilesEventTo_p_wxObject(void x) {
	4528	return (void )((wxObject ) (wxEvent ) ((wxDropFilesEvent ) x));
	4529	}
	4530	static void _p_wxFocusEventTo_p_wxObject(void x) {
	4531	return (void )((wxObject ) (wxEvent ) ((wxFocusEvent ) x));
	4532	}
	4533	static void _p_wxChildFocusEventTo_p_wxObject(void x) {
	4534	return (void )((wxObject ) (wxEvent )(wxCommandEvent ) ((wxChildFocusEvent *) x));
	4535	}
	4536	static void _p_wxGIFAnimationCtrlTo_p_wxObject(void x) {
	4537	return (void )((wxObject ) (wxEvtHandler )(wxWindow )(wxControl ) ((wxGIFAnimationCtrl ) x));
	4538	}
	4539	static void _p_wxControlWithItemsTo_p_wxObject(void x) {
	4540	return (void )((wxObject ) (wxEvtHandler )(wxWindow )(wxControl ) ((wxControlWithItems ) x));
	4541	}
	4542	static void _p_wxPyValidatorTo_p_wxObject(void x) {
	4543	return (void )((wxObject ) (wxEvtHandler )(wxValidator ) ((wxPyValidator *) x));
	4544	}
	4545	static void _p_wxValidatorTo_p_wxObject(void x) {
	4546	return (void )((wxObject ) (wxEvtHandler ) ((wxValidator ) x));
	4547	}
	4548	static void _p_wxControlTo_p_wxWindow(void x) {
	4549	return (void )((wxWindow ) ((wxControl *) x));
	4550	}
	4551	static void _p_wxControlWithItemsTo_p_wxWindow(void x) {
	4552	return (void )((wxWindow ) (wxControl ) ((wxControlWithItems ) x));
	4553	}
	4554	static void _p_wxGIFAnimationCtrlTo_p_wxWindow(void x) {
	4555	return (void )((wxWindow ) (wxControl ) ((wxGIFAnimationCtrl ) x));
	4556	}
	4557	static void _p_wxMenuBarTo_p_wxWindow(void x) {
	4558	return (void )((wxWindow ) ((wxMenuBar *) x));
	4559	}
	4560	static void _p_wxGIFAnimationTo_p_wxAnimationBase(void x) {
	4561	return (void )((wxAnimationBase ) ((wxGIFAnimation *) x));
	4562	}
	4563	static void _p_wxControlTo_p_wxEvtHandler(void x) {
	4564	return (void )((wxEvtHandler ) (wxWindow ) ((wxControl ) x));
	4565	}
	4566	static void _p_wxWindowTo_p_wxEvtHandler(void x) {
	4567	return (void )((wxEvtHandler ) ((wxWindow *) x));
	4568	}
	4569	static void _p_wxControlWithItemsTo_p_wxEvtHandler(void x) {
	4570	return (void )((wxEvtHandler ) (wxWindow )(wxControl ) ((wxControlWithItems *) x));
	4571	}
	4572	static void _p_wxPyAppTo_p_wxEvtHandler(void x) {
	4573	return (void )((wxEvtHandler ) ((wxPyApp *) x));
	4574	}
	4575	static void _p_wxGIFAnimationCtrlTo_p_wxEvtHandler(void x) {
	4576	return (void )((wxEvtHandler ) (wxWindow )(wxControl ) ((wxGIFAnimationCtrl *) x));
	4577	}
	4578	static void _p_wxValidatorTo_p_wxEvtHandler(void x) {
	4579	return (void )((wxEvtHandler ) ((wxValidator *) x));
	4580	}
	4581	static void _p_wxPyValidatorTo_p_wxEvtHandler(void x) {
	4582	return (void )((wxEvtHandler ) (wxValidator ) ((wxPyValidator ) x));
	4583	}
	4584	static void _p_wxMenuBarTo_p_wxEvtHandler(void x) {
	4585	return (void )((wxEvtHandler ) (wxWindow ) ((wxMenuBar ) x));
	4586	}
	4587	static void _p_wxMenuTo_p_wxEvtHandler(void x) {
	4588	return (void )((wxEvtHandler ) ((wxMenu *) x));
	4589	}
	4590	static void _p_wxControlWithItemsTo_p_wxControl(void x) {
	4591	return (void )((wxControl ) ((wxControlWithItems *) x));
	4592	}
	4593	static void _p_wxGIFAnimationCtrlTo_p_wxControl(void x) {
	4594	return (void )((wxControl ) ((wxGIFAnimationCtrl *) x));
	4595	}
	4596	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}};
	4597	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}};
	4598	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}};
	4599	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}};
	4600	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}};
	4601	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}};
	4602	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}};
	4603	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}};
	4604	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}};
	4605	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}};
	4606	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}};
	4607	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}};
	4608	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}};
	4609	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}};
	4610	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}};
	4611	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}};
	4612	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}};
	4613	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}};
	4614	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}};
	4615	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}};
	4616	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}};
	4617	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}};
	4618	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}};
	4619	static swig_type_info _swigt__p_wxImage[] = {{"_p_wxImage", 0, "wxImage *", 0, 0, 0, 0},{"_p_wxImage", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
	4620	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}};
	4621	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}};
	4622
	4623	static swig_type_info *swig_types_initial[] = {
	4624	_swigt__p_wxRect,
	4625	_swigt__p_wxGIFAnimationCtrl,
	4626	_swigt__p_wxObject,
	4627	_swigt__p_unsigned_char,
	4628	_swigt__p_wxColour,
	4629	_swigt__p_wxAnimationPlayer,
	4630	_swigt__p_wxWindow,
	4631	_swigt__p_unsigned_long,
	4632	_swigt__p_wxBitmap,
	4633	_swigt__p_form_ops_t,
	4634	_swigt__p_unsigned_int,
	4635	_swigt__unsigned_int,
	4636	_swigt__p_wxDuplexMode,
	4637	_swigt__p_wxGIFAnimation,
	4638	_swigt__p_char,
	4639	_swigt__p_wxAnimationBase,
	4640	_swigt__p_wxPoint,
	4641	_swigt__p_wxDC,
	4642	_swigt__p_wxEvtHandler,
	4643	_swigt__std__ptrdiff_t,
	4644	_swigt__ptrdiff_t,
	4645	_swigt__p_wxControl,
	4646	_swigt__p_wxPaperSize,
	4647	_swigt__p_wxImage,
	4648	_swigt__p_wxSize,
	4649	_swigt__p_int,
	4650	0
	4651	};
	4652
	4653
	4654	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
	4655
	4656	static swig_const_info swig_const_table[] = {
	4657	{0, 0, 0, 0.0, 0, 0}};
	4658
	4659	#ifdef __cplusplus
	4660	}
	4661	#endif
	4662
	4663
	4664	#ifdef __cplusplus
	4665	extern "C" {
	4666	#endif
	4667
	4668	/* Python-specific SWIG API */
	4669	#define SWIG_newvarlink() SWIG_Python_newvarlink()
	4670	#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
	4671	#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
	4672
	4673	/* -----------------------------------------------------------------------------
	4674	* global variable support code.
	4675	* ----------------------------------------------------------------------------- */
	4676
	4677	typedef struct swig_globalvar {
	4678	char name; / Name of global variable */
	4679	PyObject (get_attr)(); /* Return the current value */
	4680	int (set_attr)(PyObject ); /* Set the value */
	4681	struct swig_globalvar *next;
	4682	} swig_globalvar;
	4683
	4684	typedef struct swig_varlinkobject {
	4685	PyObject_HEAD
	4686	swig_globalvar *vars;
	4687	} swig_varlinkobject;
	4688
	4689	static PyObject *
	4690	swig_varlink_repr(swig_varlinkobject *v) {
	4691	v = v;
	4692	return PyString_FromString("<Swig global variables>");
	4693	}
	4694
	4695	static int
	4696	swig_varlink_print(swig_varlinkobject v, FILE fp, int flags) {
	4697	swig_globalvar *var;
	4698	flags = flags;
	4699	fprintf(fp,"Swig global variables { ");
	4700	for (var = v->vars; var; var=var->next) {
	4701	fprintf(fp,"%s", var->name);
	4702	if (var->next) fprintf(fp,", ");
	4703	}
	4704	fprintf(fp," }\n");
	4705	return 0;
	4706	}
	4707
	4708	static PyObject *
	4709	swig_varlink_getattr(swig_varlinkobject v, char n) {
	4710	swig_globalvar *var = v->vars;
	4711	while (var) {
	4712	if (strcmp(var->name,n) == 0) {
	4713	return (*var->get_attr)();
	4714	}
	4715	var = var->next;
	4716	}
	4717	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
	4718	return NULL;
	4719	}
	4720
	4721	static int
	4722	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
	4723	swig_globalvar *var = v->vars;
	4724	while (var) {
	4725	if (strcmp(var->name,n) == 0) {
	4726	return (*var->set_attr)(p);
	4727	}
	4728	var = var->next;
	4729	}
	4730	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
	4731	return 1;
	4732	}
	4733
	4734	static PyTypeObject varlinktype = {
	4735	PyObject_HEAD_INIT(0)
	4736	0, /* Number of items in variable part (ob_size) */
	4737	(char )"swigvarlink", / Type name (tp_name) */
	4738	sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
	4739	0, /* Itemsize (tp_itemsize) */
	4740	0, /* Deallocator (tp_dealloc) */
	4741	(printfunc) swig_varlink_print, /* Print (tp_print) */
	4742	(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
	4743	(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
	4744	0, /* tp_compare */
	4745	(reprfunc) swig_varlink_repr, /* tp_repr */
	4746	0, /* tp_as_number */
	4747	0, /* tp_as_sequence */
	4748	0, /* tp_as_mapping */
	4749	0, /* tp_hash */
	4750	0, /* tp_call */
	4751	0, /* tp_str */
	4752	0, /* tp_getattro */
	4753	0, /* tp_setattro */
	4754	0, /* tp_as_buffer */
	4755	0, /* tp_flags */
	4756	0, /* tp_doc */
	4757	#if PY_VERSION_HEX >= 0x02000000
	4758	0, /* tp_traverse */
	4759	0, /* tp_clear */
	4760	#endif
	4761	#if PY_VERSION_HEX >= 0x02010000
	4762	0, /* tp_richcompare */
	4763	0, /* tp_weaklistoffset */
	4764	#endif
	4765	#if PY_VERSION_HEX >= 0x02020000
	4766	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
	4767	#endif
	4768	#if PY_VERSION_HEX >= 0x02030000
	4769	0, /* tp_del */
	4770	#endif
	4771	#ifdef COUNT_ALLOCS
	4772	0,0,0,0 /* tp_alloc -> tp_next */
	4773	#endif
	4774	};
	4775
	4776	/* Create a variable linking object for use later */
	4777	static PyObject *
	4778	SWIG_Python_newvarlink(void) {
	4779	swig_varlinkobject *result = 0;
	4780	result = PyMem_NEW(swig_varlinkobject,1);
	4781	varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
	4782	result->ob_type = &varlinktype;
	4783	result->vars = 0;
	4784	result->ob_refcnt = 0;
	4785	Py_XINCREF((PyObject *) result);
	4786	return ((PyObject*) result);
	4787	}
	4788
	4789	static void
	4790	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
	4791	swig_varlinkobject *v;
	4792	swig_globalvar *gv;
	4793	v= (swig_varlinkobject *) p;
	4794	gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
	4795	gv->name = (char *) malloc(strlen(name)+1);
	4796	strcpy(gv->name,name);
	4797	gv->get_attr = get_attr;
	4798	gv->set_attr = set_attr;
	4799	gv->next = v->vars;
	4800	v->vars = gv;
	4801	}
	4802
	4803	/* -----------------------------------------------------------------------------
	4804	* constants/methods manipulation
	4805	* ----------------------------------------------------------------------------- */
	4806
	4807	/* Install Constants */
	4808	static void
	4809	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
	4810	PyObject *obj = 0;
	4811	size_t i;
	4812	for (i = 0; constants[i].type; i++) {
	4813	switch(constants[i].type) {
	4814	case SWIG_PY_INT:
	4815	obj = PyInt_FromLong(constants[i].lvalue);
	4816	break;
	4817	case SWIG_PY_FLOAT:
	4818	obj = PyFloat_FromDouble(constants[i].dvalue);
	4819	break;
	4820	case SWIG_PY_STRING:
	4821	if (constants[i].pvalue) {
	4822	obj = PyString_FromString((char *) constants[i].pvalue);
	4823	} else {
	4824	Py_INCREF(Py_None);
	4825	obj = Py_None;
	4826	}
	4827	break;
	4828	case SWIG_PY_POINTER:
	4829	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
	4830	break;
	4831	case SWIG_PY_BINARY:
	4832	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
	4833	break;
	4834	default:
	4835	obj = 0;
	4836	break;
	4837	}
	4838	if (obj) {
	4839	PyDict_SetItemString(d,constants[i].name,obj);
	4840	Py_DECREF(obj);
	4841	}
	4842	}
	4843	}
	4844
	4845	/* -----------------------------------------------------------------------------*/
	4846	/* Fix SwigMethods to carry the callback ptrs when needed */
	4847	/* -----------------------------------------------------------------------------*/
	4848
	4849	static void
	4850	SWIG_Python_FixMethods(PyMethodDef *methods,
	4851	swig_const_info *const_table,
	4852	swig_type_info **types,
	4853	swig_type_info **types_initial) {
	4854	size_t i;
	4855	for (i = 0; methods[i].ml_name; ++i) {
	4856	char *c = methods[i].ml_doc;
	4857	if (c && (c = strstr(c, "swig_ptr: "))) {
	4858	int j;
	4859	swig_const_info *ci = 0;
	4860	char *name = c + 10;
	4861	for (j = 0; const_table[j].type; j++) {
	4862	if (strncmp(const_table[j].name, name,
	4863	strlen(const_table[j].name)) == 0) {
	4864	ci = &(const_table[j]);
	4865	break;
	4866	}
	4867	}
	4868	if (ci) {
	4869	size_t shift = (ci->ptype) - types;
	4870	swig_type_info *ty = types_initial[shift];
	4871	size_t ldoc = (c - methods[i].ml_doc);
	4872	size_t lptr = strlen(ty->name)+2sizeof(void)+2;
	4873	char ndoc = (char)malloc(ldoc + lptr + 10);
	4874	char *buff = ndoc;
	4875	void ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void )(ci->lvalue);
	4876	strncpy(buff, methods[i].ml_doc, ldoc);
	4877	buff += ldoc;
	4878	strncpy(buff, "swig_ptr: ", 10);
	4879	buff += 10;
	4880	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
	4881	methods[i].ml_doc = ndoc;
	4882	}
	4883	}
	4884	}
	4885	}
	4886
	4887	/* -----------------------------------------------------------------------------*
	4888	* Initialize type list
	4889	* -----------------------------------------------------------------------------*/
	4890
	4891	#if PY_MAJOR_VERSION < 2
	4892	/* PyModule_AddObject function was introduced in Python 2.0. The following function
	4893	is copied out of Python/modsupport.c in python version 2.3.4 */
	4894	static int
	4895	PyModule_AddObject(PyObject m, char name, PyObject *o)
	4896	{
	4897	PyObject *dict;
	4898	if (!PyModule_Check(m)) {
	4899	PyErr_SetString(PyExc_TypeError,
	4900	"PyModule_AddObject() needs module as first arg");
	4901	return -1;
	4902	}
	4903	if (!o) {
	4904	PyErr_SetString(PyExc_TypeError,
	4905	"PyModule_AddObject() needs non-NULL value");
	4906	return -1;
	4907	}
	4908
	4909	dict = PyModule_GetDict(m);
	4910	if (dict == NULL) {
	4911	/* Internal error -- modules must have a dict! */
	4912	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
	4913	PyModule_GetName(m));
	4914	return -1;
	4915	}
	4916	if (PyDict_SetItemString(dict, name, o))
	4917	return -1;
	4918	Py_DECREF(o);
	4919	return 0;
	4920	}
	4921	#endif
	4922
	4923	static swig_type_info **
	4924	SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
	4925	static PyMethodDef swig_empty_runtime_method_table[] = {
	4926	{
	4927	NULL, NULL, 0, NULL
	4928	}
	4929	};/* Sentinel */
	4930
	4931	PyObject module = Py_InitModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION,
	4932	swig_empty_runtime_method_table);
	4933	PyObject pointer = PyCObject_FromVoidPtr((void ) type_list_handle, NULL);
	4934	if (pointer && module) {
	4935	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
	4936	}
	4937	return type_list_handle;
	4938	}
	4939
	4940	static swig_type_info **
	4941	SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
	4942	swig_type_info **type_pointer;
	4943
	4944	/* first check if module already created */
	4945	type_pointer = SWIG_Python_GetTypeListHandle();
	4946	if (type_pointer) {
	4947	return type_pointer;
	4948	} else {
	4949	/* create a new module and variable */
	4950	return SWIG_Python_SetTypeListHandle(type_list_handle);
	4951	}
	4952	}
	4953
	4954	#ifdef __cplusplus
	4955	}
	4956	#endif
	4957
	4958	/* -----------------------------------------------------------------------------*
	4959	* Partial Init method
	4960	* -----------------------------------------------------------------------------*/
	4961
	4962	#ifdef SWIG_LINK_RUNTIME
	4963	#ifdef __cplusplus
	4964	extern "C"
	4965	#endif
	4966	SWIGEXPORT(void ) SWIG_ReturnGlobalTypeList(void );
	4967	#endif
	4968
	4969	#ifdef __cplusplus
	4970	extern "C"
	4971	#endif
	4972	SWIGEXPORT(void) SWIG_init(void) {
	4973	static PyObject *SWIG_globals = 0;
	4974	static int typeinit = 0;
	4975	PyObject m, d;
	4976	int i;
	4977	if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
	4978
	4979	/* Fix SwigMethods to carry the callback ptrs when needed */
	4980	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
	4981
	4982	m = Py_InitModule((char *) SWIG_name, SwigMethods);
	4983	d = PyModule_GetDict(m);
	4984
	4985	if (!typeinit) {
	4986	#ifdef SWIG_LINK_RUNTIME
	4987	swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
	4988	#else
	4989	# ifndef SWIG_STATIC_RUNTIME
	4990	swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
	4991	# endif
	4992	#endif
	4993	for (i = 0; swig_types_initial[i]; i++) {
	4994	swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
	4995	}
	4996	typeinit = 1;
	4997	}
	4998	SWIG_InstallConstants(d,swig_const_table);
	4999
	5000	PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
	5001	SWIG_addvarlink(SWIG_globals,(char*)"AnimationControlNameStr",_wrap_AnimationControlNameStr_get, _wrap_AnimationControlNameStr_set);
	5002	{
	5003	PyDict_SetItemString(d,"ANIM_UNSPECIFIED", SWIG_From_int((int)(wxANIM_UNSPECIFIED)));
	5004	}
	5005	{
	5006	PyDict_SetItemString(d,"ANIM_DONOTREMOVE", SWIG_From_int((int)(wxANIM_DONOTREMOVE)));
	5007	}
	5008	{
	5009	PyDict_SetItemString(d,"ANIM_TOBACKGROUND", SWIG_From_int((int)(wxANIM_TOBACKGROUND)));
	5010	}
	5011	{
	5012	PyDict_SetItemString(d,"ANIM_TOPREVIOUS", SWIG_From_int((int)(wxANIM_TOPREVIOUS)));
	5013	}
	5014	{
	5015	PyDict_SetItemString(d,"AN_FIT_ANIMATION", SWIG_From_int((int)(wxAN_FIT_ANIMATION)));
	5016	}
	5017	}
	5018