This commit was manufactured by cvs2svn to create tag 'TCL_8_4_5'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/TCL_8_4_5@24565 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/regex/regc_color.c

@@ -0,0 +1,778 @@
+/*
+ * colorings of characters
+ * This file is #included by regcomp.c.
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ *
+ * Note that there are some incestuous relationships between this code and
+ * NFA arc maintenance, which perhaps ought to be cleaned up sometime.
+ */
+
+
+
+#define	CISERR()	VISERR(cm->v)
+#define	CERR(e)		VERR(cm->v, (e))
+
+
+
+/*
+ - initcm - set up new colormap
+ ^ static VOID initcm(struct vars *, struct colormap *);
+ */
+static VOID
+initcm(v, cm)
+struct vars *v;
+struct colormap *cm;
+{
+	int i;
+	int j;
+	union tree *t;
+	union tree *nextt;
+	struct colordesc *cd;
+
+	cm->magic = CMMAGIC;
+	cm->v = v;
+
+	cm->ncds = NINLINECDS;
+	cm->cd = cm->cdspace;
+	cm->max = 0;
+	cm->free = 0;
+
+	cd = cm->cd;			/* cm->cd[WHITE] */
+	cd->sub = NOSUB;
+	cd->arcs = NULL;
+	cd->flags = 0;
+	cd->nchrs = CHR_MAX - CHR_MIN + 1;
+
+	/* upper levels of tree */
+	for (t = &cm->tree[0], j = NBYTS-1; j > 0; t = nextt, j--) {
+		nextt = t + 1;
+		for (i = BYTTAB-1; i >= 0; i--)
+			t->tptr[i] = nextt;
+	}
+	/* bottom level is solid white */
+	t = &cm->tree[NBYTS-1];
+	for (i = BYTTAB-1; i >= 0; i--)
+		t->tcolor[i] = WHITE;
+	cd->block = t;
+}
+
+/*
+ - freecm - free dynamically-allocated things in a colormap
+ ^ static VOID freecm(struct colormap *);
+ */
+static VOID
+freecm(cm)
+struct colormap *cm;
+{
+	size_t i;
+	union tree *cb;
+
+	cm->magic = 0;
+	if (NBYTS > 1)
+		cmtreefree(cm, cm->tree, 0);
+	for (i = 1; i <= cm->max; i++)		/* skip WHITE */
+		if (!UNUSEDCOLOR(&cm->cd[i])) {
+			cb = cm->cd[i].block;
+			if (cb != NULL)
+				FREE(cb);
+		}
+	if (cm->cd != cm->cdspace)
+		FREE(cm->cd);
+}
+
+/*
+ - cmtreefree - free a non-terminal part of a colormap tree
+ ^ static VOID cmtreefree(struct colormap *, union tree *, int);
+ */
+static VOID
+cmtreefree(cm, tree, level)
+struct colormap *cm;
+union tree *tree;
+int level;			/* level number (top == 0) of this block */
+{
+	int i;
+	union tree *t;
+	union tree *fillt = &cm->tree[level+1];
+	union tree *cb;
+
+	assert(level < NBYTS-1);	/* this level has pointers */
+	for (i = BYTTAB-1; i >= 0; i--) {
+		t = tree->tptr[i];
+		assert(t != NULL);
+		if (t != fillt) {
+			if (level < NBYTS-2) {	/* more pointer blocks below */
+				cmtreefree(cm, t, level+1);
+				FREE(t);
+			} else {		/* color block below */
+				cb = cm->cd[t->tcolor[0]].block;
+				if (t != cb)	/* not a solid block */
+					FREE(t);
+			}
+		}
+	}
+}
+
+/*
+ - setcolor - set the color of a character in a colormap
+ ^ static color setcolor(struct colormap *, pchr, pcolor);
+ */
+static color			/* previous color */
+setcolor(cm, c, co)
+struct colormap *cm;
+pchr c;
+pcolor co;
+{
+	uchr uc = c;
+	int shift;
+	int level;
+	int b;
+	int bottom;
+	union tree *t;
+	union tree *newt;
+	union tree *fillt;
+	union tree *lastt;
+	union tree *cb;
+	color prev;
+
+	assert(cm->magic == CMMAGIC);
+	if (CISERR() || co == COLORLESS)
+		return COLORLESS;
+
+	t = cm->tree;
+	for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
+						level++, shift -= BYTBITS) {
+		b = (uc >> shift) & BYTMASK;
+		lastt = t;
+		t = lastt->tptr[b];
+		assert(t != NULL);
+		fillt = &cm->tree[level+1];
+		bottom = (shift <= BYTBITS) ? 1 : 0;
+		cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;
+		if (t == fillt || t == cb) {	/* must allocate a new block */
+			newt = (union tree *)MALLOC((bottom) ?
+				sizeof(struct colors) : sizeof(struct ptrs));
+			if (newt == NULL) {
+				CERR(REG_ESPACE);
+				return COLORLESS;
+			}
+			if (bottom)
+				memcpy(VS(newt->tcolor), VS(t->tcolor),
+							BYTTAB*sizeof(color));
+			else
+				memcpy(VS(newt->tptr), VS(t->tptr),
+						BYTTAB*sizeof(union tree *));
+			t = newt;
+			lastt->tptr[b] = t;
+		}
+	}
+
+	b = uc & BYTMASK;
+	prev = t->tcolor[b];
+	t->tcolor[b] = (color)co;
+	return prev;
+}
+
+/*
+ - maxcolor - report largest color number in use
+ ^ static color maxcolor(struct colormap *);
+ */
+static color
+maxcolor(cm)
+struct colormap *cm;
+{
+	if (CISERR())
+		return COLORLESS;
+
+	return (color)cm->max;
+}
+
+/*
+ - newcolor - find a new color (must be subject of setcolor at once)
+ * Beware:  may relocate the colordescs.
+ ^ static color newcolor(struct colormap *);
+ */
+static color			/* COLORLESS for error */
+newcolor(cm)
+struct colormap *cm;
+{
+	struct colordesc *cd;
+	struct colordesc *new;
+	size_t n;
+
+	if (CISERR())
+		return COLORLESS;
+
+	if (cm->free != 0) {
+		assert(cm->free > 0);
+		assert((size_t)cm->free < cm->ncds);
+		cd = &cm->cd[cm->free];
+		assert(UNUSEDCOLOR(cd));
+		assert(cd->arcs == NULL);
+		cm->free = cd->sub;
+	} else if (cm->max < cm->ncds - 1) {
+		cm->max++;
+		cd = &cm->cd[cm->max];
+	} else {
+		/* oops, must allocate more */
+		n = cm->ncds * 2;
+		if (cm->cd == cm->cdspace) {
+			new = (struct colordesc *)MALLOC(n *
+						sizeof(struct colordesc));
+			if (new != NULL)
+				memcpy(VS(new), VS(cm->cdspace), cm->ncds *
+						sizeof(struct colordesc));
+		} else
+			new = (struct colordesc *)REALLOC(cm->cd,
+						n * sizeof(struct colordesc));
+		if (new == NULL) {
+			CERR(REG_ESPACE);
+			return COLORLESS;
+		}
+		cm->cd = new;
+		cm->ncds = n;
+		assert(cm->max < cm->ncds - 1);
+		cm->max++;
+		cd = &cm->cd[cm->max];
+	}
+
+	cd->nchrs = 0;
+	cd->sub = NOSUB;
+	cd->arcs = NULL;
+	cd->flags = 0;
+	cd->block = NULL;
+
+	return (color)(cd - cm->cd);
+}
+
+/*
+ - freecolor - free a color (must have no arcs or subcolor)
+ ^ static VOID freecolor(struct colormap *, pcolor);
+ */
+static VOID
+freecolor(cm, co)
+struct colormap *cm;
+pcolor co;
+{
+	struct colordesc *cd = &cm->cd[co];
+	color pco, nco;			/* for freelist scan */
+
+	assert(co >= 0);
+	if (co == WHITE)
+		return;
+
+	assert(cd->arcs == NULL);
+	assert(cd->sub == NOSUB);
+	assert(cd->nchrs == 0);
+	cd->flags = FREECOL;
+	if (cd->block != NULL) {
+		FREE(cd->block);
+		cd->block = NULL;	/* just paranoia */
+	}
+
+	if ((size_t)co == cm->max) {
+		while (cm->max > WHITE && UNUSEDCOLOR(&cm->cd[cm->max]))
+			cm->max--;
+		assert(cm->free >= 0);
+		while ((size_t)cm->free > cm->max)
+			cm->free = cm->cd[cm->free].sub;
+		if (cm->free > 0) {
+			assert(cm->free < cm->max);
+			pco = cm->free;
+			nco = cm->cd[pco].sub;
+			while (nco > 0)
+				if ((size_t)nco > cm->max) {
+					/* take this one out of freelist */
+					nco = cm->cd[nco].sub;
+					cm->cd[pco].sub = nco;
+				} else {
+					assert(nco < cm->max);
+					pco = nco;
+					nco = cm->cd[pco].sub;
+				}
+		}
+	} else {
+		cd->sub = cm->free;
+		cm->free = (color)(cd - cm->cd);
+	}
+}
+
+/*
+ - pseudocolor - allocate a false color, to be managed by other means
+ ^ static color pseudocolor(struct colormap *);
+ */
+static color
+pseudocolor(cm)
+struct colormap *cm;
+{
+	color co;
+
+	co = newcolor(cm);
+	if (CISERR())
+		return COLORLESS;
+	cm->cd[co].nchrs = 1;
+	cm->cd[co].flags = PSEUDO;
+	return co;
+}
+
+/*
+ - subcolor - allocate a new subcolor (if necessary) to this chr
+ ^ static color subcolor(struct colormap *, pchr c);
+ */
+static color
+subcolor(cm, c)
+struct colormap *cm;
+pchr c;
+{
+	color co;			/* current color of c */
+	color sco;			/* new subcolor */
+
+	co = GETCOLOR(cm, c);
+	sco = newsub(cm, co);
+	if (CISERR())
+		return COLORLESS;
+	assert(sco != COLORLESS);
+
+	if (co == sco)		/* already in an open subcolor */
+		return co;	/* rest is redundant */
+	cm->cd[co].nchrs--;
+	cm->cd[sco].nchrs++;
+	setcolor(cm, c, sco);
+	return sco;
+}
+
+/*
+ - newsub - allocate a new subcolor (if necessary) for a color
+ ^ static color newsub(struct colormap *, pcolor);
+ */
+static color
+newsub(cm, co)
+struct colormap *cm;
+pcolor co;
+{
+	color sco;			/* new subcolor */
+
+	sco = cm->cd[co].sub;
+	if (sco == NOSUB) {		/* color has no open subcolor */
+		if (cm->cd[co].nchrs == 1)	/* optimization */
+			return co;
+		sco = newcolor(cm);	/* must create subcolor */
+		if (sco == COLORLESS) {
+			assert(CISERR());
+			return COLORLESS;
+		}
+		cm->cd[co].sub = sco;
+		cm->cd[sco].sub = sco;	/* open subcolor points to self */
+	}
+	assert(sco != NOSUB);
+
+	return sco;
+}
+
+/*
+ - subrange - allocate new subcolors to this range of chrs, fill in arcs
+ ^ static VOID subrange(struct vars *, pchr, pchr, struct state *,
+ ^ 	struct state *);
+ */
+static VOID
+subrange(v, from, to, lp, rp)
+struct vars *v;
+pchr from;
+pchr to;
+struct state *lp;
+struct state *rp;
+{
+	uchr uf;
+	int i;
+
+	assert(from <= to);
+
+	/* first, align "from" on a tree-block boundary */
+	uf = (uchr)from;
+	i = (int)( ((uf + BYTTAB-1) & (uchr)~BYTMASK) - uf );
+	for (; from <= to && i > 0; i--, from++)
+		newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
+	if (from > to)			/* didn't reach a boundary */
+		return;
+
+	/* deal with whole blocks */
+	for (; to - from >= BYTTAB; from += BYTTAB)
+		subblock(v, from, lp, rp);
+
+	/* clean up any remaining partial table */
+	for (; from <= to; from++)
+		newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
+}
+
+/*
+ - subblock - allocate new subcolors for one tree block of chrs, fill in arcs
+ ^ static VOID subblock(struct vars *, pchr, struct state *, struct state *);
+ */
+static VOID
+subblock(v, start, lp, rp)
+struct vars *v;
+pchr start;			/* first of BYTTAB chrs */
+struct state *lp;
+struct state *rp;
+{
+	uchr uc = start;
+	struct colormap *cm = v->cm;
+	int shift;
+	int level;
+	int i;
+	int b;
+	union tree *t;
+	union tree *cb;
+	union tree *fillt;
+	union tree *lastt;
+	int previ;
+	int ndone;
+	color co;
+	color sco;
+
+	assert((uc % BYTTAB) == 0);
+
+	/* find its color block, making new pointer blocks as needed */
+	t = cm->tree;
+	fillt = NULL;
+	for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
+						level++, shift -= BYTBITS) {
+		b = (uc >> shift) & BYTMASK;
+		lastt = t;
+		t = lastt->tptr[b];
+		assert(t != NULL);
+		fillt = &cm->tree[level+1];
+		if (t == fillt && shift > BYTBITS) {	/* need new ptr block */
+			t = (union tree *)MALLOC(sizeof(struct ptrs));
+			if (t == NULL) {
+				CERR(REG_ESPACE);
+				return;
+			}
+			memcpy(VS(t->tptr), VS(fillt->tptr),
+						BYTTAB*sizeof(union tree *));
+			lastt->tptr[b] = t;
+		}
+	}
+
+	/* special cases:  fill block or solid block */
+	co = t->tcolor[0];
+	cb = cm->cd[co].block;
+	if (t == fillt || t == cb) {
+		/* either way, we want a subcolor solid block */
+		sco = newsub(cm, co);
+		t = cm->cd[sco].block;
+		if (t == NULL) {	/* must set it up */
+			t = (union tree *)MALLOC(sizeof(struct colors));
+			if (t == NULL) {
+				CERR(REG_ESPACE);
+				return;
+			}
+			for (i = 0; i < BYTTAB; i++)
+				t->tcolor[i] = sco;
+			cm->cd[sco].block = t;
+		}
+		/* find loop must have run at least once */
+		lastt->tptr[b] = t;
+		newarc(v->nfa, PLAIN, sco, lp, rp);
+		cm->cd[co].nchrs -= BYTTAB;
+		cm->cd[sco].nchrs += BYTTAB;
+		return;
+	}
+
+	/* general case, a mixed block to be altered */
+	i = 0;
+	while (i < BYTTAB) {
+		co = t->tcolor[i];
+		sco = newsub(cm, co);
+		newarc(v->nfa, PLAIN, sco, lp, rp);
+		previ = i;
+		do {
+			t->tcolor[i++] = sco;
+		} while (i < BYTTAB && t->tcolor[i] == co);
+		ndone = i - previ;
+		cm->cd[co].nchrs -= ndone;
+		cm->cd[sco].nchrs += ndone;
+	}
+}
+
+/*
+ - okcolors - promote subcolors to full colors
+ ^ static VOID okcolors(struct nfa *, struct colormap *);
+ */
+static VOID
+okcolors(nfa, cm)
+struct nfa *nfa;
+struct colormap *cm;
+{
+	struct colordesc *cd;
+	struct colordesc *end = CDEND(cm);
+	struct colordesc *scd;
+	struct arc *a;
+	color co;
+	color sco;
+
+	for (cd = cm->cd, co = 0; cd < end; cd++, co++) {
+		sco = cd->sub;
+		if (UNUSEDCOLOR(cd) || sco == NOSUB) {
+			/* has no subcolor, no further action */
+		} else if (sco == co) {
+			/* is subcolor, let parent deal with it */
+		} else if (cd->nchrs == 0) {
+			/* parent empty, its arcs change color to subcolor */
+			cd->sub = NOSUB;
+			scd = &cm->cd[sco];
+			assert(scd->nchrs > 0);
+			assert(scd->sub == sco);
+			scd->sub = NOSUB;
+			while ((a = cd->arcs) != NULL) {
+				assert(a->co == co);
+				/* uncolorchain(cm, a); */
+				cd->arcs = a->colorchain;
+				a->co = sco;
+				/* colorchain(cm, a); */
+				a->colorchain = scd->arcs;
+				scd->arcs = a;
+			}
+			freecolor(cm, co);
+		} else {
+			/* parent's arcs must gain parallel subcolor arcs */
+			cd->sub = NOSUB;
+			scd = &cm->cd[sco];
+			assert(scd->nchrs > 0);
+			assert(scd->sub == sco);
+			scd->sub = NOSUB;
+			for (a = cd->arcs; a != NULL; a = a->colorchain) {
+				assert(a->co == co);
+				newarc(nfa, a->type, sco, a->from, a->to);
+			}
+		}
+	}
+}
+
+/*
+ - colorchain - add this arc to the color chain of its color
+ ^ static VOID colorchain(struct colormap *, struct arc *);
+ */
+static VOID
+colorchain(cm, a)
+struct colormap *cm;
+struct arc *a;
+{
+	struct colordesc *cd = &cm->cd[a->co];
+
+	a->colorchain = cd->arcs;
+	cd->arcs = a;
+}
+
+/*
+ - uncolorchain - delete this arc from the color chain of its color
+ ^ static VOID uncolorchain(struct colormap *, struct arc *);
+ */
+static VOID
+uncolorchain(cm, a)
+struct colormap *cm;
+struct arc *a;
+{
+	struct colordesc *cd = &cm->cd[a->co];
+	struct arc *aa;
+
+	aa = cd->arcs;
+	if (aa == a)		/* easy case */
+		cd->arcs = a->colorchain;
+	else {
+		for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain)
+			continue;
+		assert(aa != NULL);
+		aa->colorchain = a->colorchain;
+	}
+	a->colorchain = NULL;	/* paranoia */
+}
+
+/*
+ - singleton - is this character in its own color?
+ ^ static int singleton(struct colormap *, pchr c);
+ */
+static int			/* predicate */
+singleton(cm, c)
+struct colormap *cm;
+pchr c;
+{
+	color co;			/* color of c */
+
+	co = GETCOLOR(cm, c);
+	if (cm->cd[co].nchrs == 1 && cm->cd[co].sub == NOSUB)
+		return 1;
+	return 0;
+}
+
+/*
+ - rainbow - add arcs of all full colors (but one) between specified states
+ ^ static VOID rainbow(struct nfa *, struct colormap *, int, pcolor,
+ ^ 	struct state *, struct state *);
+ */
+static VOID
+rainbow(nfa, cm, type, but, from, to)
+struct nfa *nfa;
+struct colormap *cm;
+int type;
+pcolor but;			/* COLORLESS if no exceptions */
+struct state *from;
+struct state *to;
+{
+	struct colordesc *cd;
+	struct colordesc *end = CDEND(cm);
+	color co;
+
+	for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
+		if (!UNUSEDCOLOR(cd) && cd->sub != co && co != but &&
+							!(cd->flags&PSEUDO))
+			newarc(nfa, type, co, from, to);
+}
+
+/*
+ - colorcomplement - add arcs of complementary colors
+ * The calling sequence ought to be reconciled with cloneouts().
+ ^ static VOID colorcomplement(struct nfa *, struct colormap *, int,
+ ^ 	struct state *, struct state *, struct state *);
+ */
+static VOID
+colorcomplement(nfa, cm, type, of, from, to)
+struct nfa *nfa;
+struct colormap *cm;
+int type;
+struct state *of;		/* complements of this guy's PLAIN outarcs */
+struct state *from;
+struct state *to;
+{
+	struct colordesc *cd;
+	struct colordesc *end = CDEND(cm);
+	color co;
+
+	assert(of != from);
+	for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
+		if (!UNUSEDCOLOR(cd) && !(cd->flags&PSEUDO))
+			if (findarc(of, PLAIN, co) == NULL)
+				newarc(nfa, type, co, from, to);
+}
+
+
+
+#ifdef REG_DEBUG
+/*
+ ^ #ifdef REG_DEBUG
+ */
+
+/*
+ - dumpcolors - debugging output
+ ^ static VOID dumpcolors(struct colormap *, FILE *);
+ */
+static VOID
+dumpcolors(cm, f)
+struct colormap *cm;
+FILE *f;
+{
+	struct colordesc *cd;
+	struct colordesc *end;
+	color co;
+	chr c;
+	char *has;
+
+	fprintf(f, "max %ld\n", (long)cm->max);
+	if (NBYTS > 1)
+		fillcheck(cm, cm->tree, 0, f);
+	end = CDEND(cm);
+	for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++)	/* skip 0 */
+		if (!UNUSEDCOLOR(cd)) {
+			assert(cd->nchrs > 0);
+			has = (cd->block != NULL) ? "#" : "";
+			if (cd->flags&PSEUDO)
+				fprintf(f, "#%2ld%s(ps): ", (long)co, has);
+			else
+				fprintf(f, "#%2ld%s(%2d): ", (long)co,
+							has, cd->nchrs);
+			/* it's hard to do this more efficiently */
+			for (c = CHR_MIN; c < CHR_MAX; c++)
+				if (GETCOLOR(cm, c) == co)
+					dumpchr(c, f);
+			assert(c == CHR_MAX);
+			if (GETCOLOR(cm, c) == co)
+				dumpchr(c, f);
+			fprintf(f, "\n");
+		}
+}
+
+/*
+ - fillcheck - check proper filling of a tree
+ ^ static VOID fillcheck(struct colormap *, union tree *, int, FILE *);
+ */
+static VOID
+fillcheck(cm, tree, level, f)
+struct colormap *cm;
+union tree *tree;
+int level;			/* level number (top == 0) of this block */
+FILE *f;
+{
+	int i;
+	union tree *t;
+	union tree *fillt = &cm->tree[level+1];
+
+	assert(level < NBYTS-1);	/* this level has pointers */
+	for (i = BYTTAB-1; i >= 0; i--) {
+		t = tree->tptr[i];
+		if (t == NULL)
+			fprintf(f, "NULL found in filled tree!\n");
+		else if (t == fillt)
+			{}
+		else if (level < NBYTS-2)	/* more pointer blocks below */
+			fillcheck(cm, t, level+1, f);
+	}
+}
+
+/*
+ - dumpchr - print a chr
+ * Kind of char-centric but works well enough for debug use.
+ ^ static VOID dumpchr(pchr, FILE *);
+ */
+static VOID
+dumpchr(c, f)
+pchr c;
+FILE *f;
+{
+	if (c == '\\')
+		fprintf(f, "\\\\");
+	else if (c > ' ' && c <= '~')
+		putc((char)c, f);
+	else
+		fprintf(f, "\\u%04lx", (long)c);
+}
+
+/*
+ ^ #endif
+ */
+#endif				/* ifdef REG_DEBUG */

src/regex/regc_cvec.c

@@ -0,0 +1,208 @@
+/*
+ * Utility functions for handling cvecs
+ * This file is #included by regcomp.c.
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*
+ - newcvec - allocate a new cvec
+ ^ static struct cvec *newcvec(int, int, int);
+ */
+static struct cvec *
+newcvec(nchrs, nranges, nmcces)
+    int nchrs;				/* to hold this many chrs... */
+    int nranges;			/* ... and this many ranges... */
+    int nmcces;				/* ... and this many MCCEs */
+{
+    size_t n;
+    size_t nc;
+    struct cvec *cv;
+
+    nc = (size_t)nchrs + (size_t)nmcces*(MAXMCCE+1) + (size_t)nranges*2;
+    n = sizeof(struct cvec) + (size_t)(nmcces-1)*sizeof(chr *)
+	    + nc*sizeof(chr);
+    cv = (struct cvec *)MALLOC(n);
+    if (cv == NULL) {
+	return NULL;
+    }
+    cv->chrspace = nchrs;
+    cv->chrs = (chr *)&cv->mcces[nmcces];	/* chrs just after MCCE ptrs */
+    cv->mccespace = nmcces;
+    cv->ranges = cv->chrs + nchrs + nmcces*(MAXMCCE+1);
+    cv->rangespace = nranges;
+    return clearcvec(cv);
+}
+
+/*
+ - clearcvec - clear a possibly-new cvec
+ * Returns pointer as convenience.
+ ^ static struct cvec *clearcvec(struct cvec *);
+ */
+static struct cvec *
+clearcvec(cv)
+    struct cvec *cv;			/* character vector */
+{
+    int i;
+
+    assert(cv != NULL);
+    cv->nchrs = 0;
+    assert(cv->chrs == (chr *)&cv->mcces[cv->mccespace]);
+    cv->nmcces = 0;
+    cv->nmccechrs = 0;
+    cv->nranges = 0;
+    for (i = 0; i < cv->mccespace; i++) {
+	cv->mcces[i] = NULL;
+    }
+
+    return cv;
+}
+
+/*
+ - addchr - add a chr to a cvec
+ ^ static VOID addchr(struct cvec *, pchr);
+ */
+static VOID
+addchr(cv, c)
+    struct cvec *cv;			/* character vector */
+    pchr c;				/* character to add */
+{
+    assert(cv->nchrs < cv->chrspace - cv->nmccechrs);
+    cv->chrs[cv->nchrs++] = (chr)c;
+}
+
+/*
+ - addrange - add a range to a cvec
+ ^ static VOID addrange(struct cvec *, pchr, pchr);
+ */
+static VOID
+addrange(cv, from, to)
+    struct cvec *cv;			/* character vector */
+    pchr from;				/* first character of range */
+    pchr to;				/* last character of range */
+{
+    assert(cv->nranges < cv->rangespace);
+    cv->ranges[cv->nranges*2] = (chr)from;
+    cv->ranges[cv->nranges*2 + 1] = (chr)to;
+    cv->nranges++;
+}
+
+/*
+ - addmcce - add an MCCE to a cvec
+ ^ static VOID addmcce(struct cvec *, chr *, chr *);
+ */
+static VOID
+addmcce(cv, startp, endp)
+    struct cvec *cv;			/* character vector */
+    chr *startp;			/* beginning of text */
+    chr *endp;				/* just past end of text */
+{
+    int len;
+    int i;
+    chr *s;
+    chr *d;
+
+    if (startp == NULL && endp == NULL) {
+	return;
+    }
+    len = endp - startp;
+    assert(len > 0);
+    assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs);
+    assert(cv->nmcces < cv->mccespace);
+    d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1];
+    cv->mcces[cv->nmcces++] = d;
+    for (s = startp, i = len; i > 0; s++, i--) {
+	*d++ = *s;
+    }
+    *d++ = 0;				/* endmarker */
+    assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]);
+    cv->nmccechrs += len + 1;
+}
+
+/*
+ - haschr - does a cvec contain this chr?
+ ^ static int haschr(struct cvec *, pchr);
+ */
+static int				/* predicate */
+haschr(cv, c)
+    struct cvec *cv;			/* character vector */
+    pchr c;				/* character to test for */
+{
+    int i;
+    chr *p;
+
+    for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--) {
+	if (*p == c) {
+	    return 1;
+	}
+    }
+    for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--) {
+	if ((*p <= c) && (c <= *(p+1))) {
+	    return 1;
+	}
+    }
+    return 0;
+}
+
+/*
+ - getcvec - get a cvec, remembering it as v->cv
+ ^ static struct cvec *getcvec(struct vars *, int, int, int);
+ */
+static struct cvec *
+getcvec(v, nchrs, nranges, nmcces)
+    struct vars *v;			/* context */
+    int nchrs;				/* to hold this many chrs... */
+    int nranges;			/* ... and this many ranges... */
+    int nmcces;				/* ... and this many MCCEs */
+{
+    if (v->cv != NULL && nchrs <= v->cv->chrspace &&
+	    nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace) {
+	return clearcvec(v->cv);
+    }
+
+    if (v->cv != NULL) {
+	freecvec(v->cv);
+    }
+    v->cv = newcvec(nchrs, nranges, nmcces);
+    if (v->cv == NULL) {
+	ERR(REG_ESPACE);
+    }
+
+    return v->cv;
+}
+
+/*
+ - freecvec - free a cvec
+ ^ static VOID freecvec(struct cvec *);
+ */
+static VOID
+freecvec(cv)
+    struct cvec *cv;			/* character vector */
+{
+    FREE(cv);
+}

src/regex/regc_locale.c

@@ -0,0 +1,989 @@
+/* 
+ * regc_locale.c --
+ *
+ *	This file contains the Unicode locale specific regexp routines.
+ *	This file is #included by regcomp.c.
+ *
+ * Copyright (c) 1998 by Scriptics Corporation.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id$
+ */
+
+/* ASCII character-name table */
+
+static struct cname {
+    char *name;
+    char code;
+} cnames[] = {
+    {"NUL",		'\0'},
+    {"SOH",		'\001'},
+    {"STX",		'\002'},
+    {"ETX",		'\003'},
+    {"EOT",		'\004'},
+    {"ENQ",		'\005'},
+    {"ACK",		'\006'},
+    {"BEL",		'\007'},
+    {"alert",		'\007'},
+    {"BS",		'\010'},
+    {"backspace",	'\b'},
+    {"HT",		'\011'},
+    {"tab",		'\t'},
+    {"LF",		'\012'},
+    {"newline",		'\n'},
+    {"VT",		'\013'},
+    {"vertical-tab",	'\v'},
+    {"FF",		'\014'},
+    {"form-feed",	'\f'},
+    {"CR",		'\015'},
+    {"carriage-return",	'\r'},
+    {"SO",		'\016'},
+    {"SI",		'\017'},
+    {"DLE",		'\020'},
+    {"DC1",		'\021'},
+    {"DC2",		'\022'},
+    {"DC3",		'\023'},
+    {"DC4",		'\024'},
+    {"NAK",		'\025'},
+    {"SYN",		'\026'},
+    {"ETB",		'\027'},
+    {"CAN",		'\030'},
+    {"EM",		'\031'},
+    {"SUB",		'\032'},
+    {"ESC",		'\033'},
+    {"IS4",		'\034'},
+    {"FS",		'\034'},
+    {"IS3",		'\035'},
+    {"GS",		'\035'},
+    {"IS2",		'\036'},
+    {"RS",		'\036'},
+    {"IS1",		'\037'},
+    {"US",		'\037'},
+    {"space",		' '},
+    {"exclamation-mark",'!'},
+    {"quotation-mark",	'"'},
+    {"number-sign",	'#'},
+    {"dollar-sign",	'$'},
+    {"percent-sign",	'%'},
+    {"ampersand",	'&'},
+    {"apostrophe",	'\''},
+    {"left-parenthesis",'('},
+    {"right-parenthesis", ')'},
+    {"asterisk",	'*'},
+    {"plus-sign",	'+'},
+    {"comma",		','},
+    {"hyphen",		'-'},
+    {"hyphen-minus",	'-'},
+    {"period",		'.'},
+    {"full-stop",	'.'},
+    {"slash",		'/'},
+    {"solidus",		'/'},
+    {"zero",		'0'},
+    {"one",		'1'},
+    {"two",		'2'},
+    {"three",		'3'},
+    {"four",		'4'},
+    {"five",		'5'},
+    {"six",		'6'},
+    {"seven",		'7'},
+    {"eight",		'8'},
+    {"nine",		'9'},
+    {"colon",		':'},
+    {"semicolon",	';'},
+    {"less-than-sign",	'<'},
+    {"equals-sign",	'='},
+    {"greater-than-sign", '>'},
+    {"question-mark",	'?'},
+    {"commercial-at",	'@'},
+    {"left-square-bracket", '['},
+    {"backslash",	'\\'},
+    {"reverse-solidus",	'\\'},
+    {"right-square-bracket", ']'},
+    {"circumflex",	'^'},
+    {"circumflex-accent", '^'},
+    {"underscore",	'_'},
+    {"low-line",	'_'},
+    {"grave-accent",	'`'},
+    {"left-brace",	'{'},
+    {"left-curly-bracket", '{'},
+    {"vertical-line",	'|'},
+    {"right-brace",	'}'},
+    {"right-curly-bracket", '}'},
+    {"tilde",		'~'},
+    {"DEL",		'\177'},
+    {NULL,		0}
+};
+
+/* Unicode character-class tables */
+
+typedef struct crange {
+    chr start;
+    chr end;
+} crange;
+
+/*
+ *	Declarations of Unicode character ranges.  This code
+ *	is automatically generated by the tools/uniClass.tcl script
+ *	and used in generic/regc_locale.c.  Do not modify by hand.
+ */
+
+/* Unicode: alphabetic characters */
+
+static crange alphaRangeTable[] = {
+    {0x0041, 0x005a}, {0x0061, 0x007a}, {0x00c0, 0x00d6}, {0x00d8, 0x00f6}, 
+    {0x00f8, 0x021f}, {0x0222, 0x0233}, {0x0250, 0x02ad}, {0x02b0, 0x02b8}, 
+    {0x02bb, 0x02c1}, {0x02e0, 0x02e4}, {0x0388, 0x038a}, {0x038e, 0x03a1}, 
+    {0x03a3, 0x03ce}, {0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x0481}, 
+    {0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0561, 0x0587}, 
+    {0x05d0, 0x05ea}, {0x05f0, 0x05f2}, {0x0621, 0x063a}, {0x0640, 0x064a}, 
+    {0x0671, 0x06d3}, {0x06fa, 0x06fc}, {0x0712, 0x072c}, {0x0780, 0x07a5}, 
+    {0x0905, 0x0939}, {0x0958, 0x0961}, {0x0985, 0x098c}, {0x0993, 0x09a8}, 
+    {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09df, 0x09e1}, {0x0a05, 0x0a0a}, 
+    {0x0a13, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a59, 0x0a5c}, {0x0a72, 0x0a74}, 
+    {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0}, 
+    {0x0ab5, 0x0ab9}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b28}, {0x0b2a, 0x0b30}, 
+    {0x0b36, 0x0b39}, {0x0b5f, 0x0b61}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90}, 
+    {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9}, 
+    {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c28}, {0x0c2a, 0x0c33}, 
+    {0x0c35, 0x0c39}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8}, 
+    {0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10}, 
+    {0x0d12, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1}, 
+    {0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0e01, 0x0e30}, {0x0e40, 0x0e46}, 
+    {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb0}, 
+    {0x0ec0, 0x0ec4}, {0x0f40, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f88, 0x0f8b}, 
+    {0x1000, 0x1021}, {0x1023, 0x1027}, {0x1050, 0x1055}, {0x10a0, 0x10c5}, 
+    {0x10d0, 0x10f6}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9}, 
+    {0x1200, 0x1206}, {0x1208, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256}, 
+    {0x125a, 0x125d}, {0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae}, 
+    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce}, 
+    {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315}, 
+    {0x1318, 0x131e}, {0x1320, 0x1346}, {0x1348, 0x135a}, {0x13a0, 0x13f4}, 
+    {0x1401, 0x166c}, {0x166f, 0x1676}, {0x1681, 0x169a}, {0x16a0, 0x16ea}, 
+    {0x1780, 0x17b3}, {0x1820, 0x1877}, {0x1880, 0x18a8}, {0x1e00, 0x1e9b}, 
+    {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, 
+    {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, 
+    {0x1fb6, 0x1fbc}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, 
+    {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, 
+    {0x210a, 0x2113}, {0x2119, 0x211d}, {0x212a, 0x212d}, {0x212f, 0x2131}, 
+    {0x2133, 0x2139}, {0x3031, 0x3035}, {0x3041, 0x3094}, {0x30a1, 0x30fa}, 
+    {0x30fc, 0x30fe}, {0x3105, 0x312c}, {0x3131, 0x318e}, {0x31a0, 0x31b7}, 
+    {0x3400, 0x4db5}, {0x4e00, 0x9fa5}, {0xa000, 0xa48c}, {0xac00, 0xd7a3}, 
+    {0xf900, 0xfa2d}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1f, 0xfb28}, 
+    {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d}, 
+    {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, {0xfe70, 0xfe72}, 
+    {0xfe76, 0xfefc}, {0xff21, 0xff3a}, {0xff41, 0xff5a}, {0xff66, 0xffbe}, 
+    {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc}
+};
+
+#define NUM_ALPHA_RANGE (sizeof(alphaRangeTable)/sizeof(crange))
+
+static chr alphaCharTable[] = {
+    0x00aa, 0x00b5, 0x00ba, 0x02d0, 0x02d1, 0x02ee, 0x037a, 0x0386, 0x038c, 
+    0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0559, 0x06d5, 0x06e5, 
+    0x06e6, 0x0710, 0x093d, 0x0950, 0x098f, 0x0990, 0x09b2, 0x09dc, 0x09dd, 
+    0x09f0, 0x09f1, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 
+    0x0a39, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0abd, 0x0ad0, 0x0ae0, 0x0b0f, 
+    0x0b10, 0x0b32, 0x0b33, 0x0b3d, 0x0b5c, 0x0b5d, 0x0b99, 0x0b9a, 0x0b9c, 
+    0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0c60, 0x0c61, 0x0cde, 0x0ce0, 0x0ce1, 
+    0x0d60, 0x0d61, 0x0dbd, 0x0e32, 0x0e33, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 
+    0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0eb2, 0x0eb3, 
+    0x0ebd, 0x0ec6, 0x0edc, 0x0edd, 0x0f00, 0x1029, 0x102a, 0x1248, 0x1258, 
+    0x1288, 0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x1fbe, 0x207f, 
+    0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x3005, 0x3006, 0x309d, 
+    0x309e, 0xfb1d, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74, 0xfffe
+};
+
+#define NUM_ALPHA_CHAR (sizeof(alphaCharTable)/sizeof(chr))
+
+/* Unicode: decimal digit characters */
+
+static crange digitRangeTable[] = {
+    {0x0030, 0x0039}, {0x0660, 0x0669}, {0x06f0, 0x06f9}, {0x0966, 0x096f}, 
+    {0x09e6, 0x09ef}, {0x0a66, 0x0a6f}, {0x0ae6, 0x0aef}, {0x0b66, 0x0b6f}, 
+    {0x0be7, 0x0bef}, {0x0c66, 0x0c6f}, {0x0ce6, 0x0cef}, {0x0d66, 0x0d6f}, 
+    {0x0e50, 0x0e59}, {0x0ed0, 0x0ed9}, {0x0f20, 0x0f29}, {0x1040, 0x1049}, 
+    {0x1369, 0x1371}, {0x17e0, 0x17e9}, {0x1810, 0x1819}, {0xff10, 0xff19}
+};
+
+#define NUM_DIGIT_RANGE (sizeof(digitRangeTable)/sizeof(crange))
+
+/* no singletons of digit characters */
+
+/* Unicode: punctuation characters */
+
+static crange punctRangeTable[] = {
+    {0x0021, 0x0023}, {0x0025, 0x002a}, {0x002c, 0x002f}, {0x005b, 0x005d}, 
+    {0x055a, 0x055f}, {0x066a, 0x066d}, {0x0700, 0x070d}, {0x0f04, 0x0f12}, 
+    {0x0f3a, 0x0f3d}, {0x104a, 0x104f}, {0x1361, 0x1368}, {0x16eb, 0x16ed}, 
+    {0x17d4, 0x17da}, {0x1800, 0x180a}, {0x2010, 0x2027}, {0x2030, 0x2043}, 
+    {0x2048, 0x204d}, {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f}, 
+    {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe61}, {0xff01, 0xff03}, 
+    {0xff05, 0xff0a}, {0xff0c, 0xff0f}, {0xff3b, 0xff3d}, {0xff61, 0xff65}
+};
+
+#define NUM_PUNCT_RANGE (sizeof(punctRangeTable)/sizeof(crange))
+
+static chr punctCharTable[] = {
+    0x003a, 0x003b, 0x003f, 0x0040, 0x005f, 0x007b, 0x007d, 0x00a1, 0x00ab, 
+    0x00ad, 0x00b7, 0x00bb, 0x00bf, 0x037e, 0x0387, 0x0589, 0x058a, 0x05be, 
+    0x05c0, 0x05c3, 0x05f3, 0x05f4, 0x060c, 0x061b, 0x061f, 0x06d4, 0x0964, 
+    0x0965, 0x0970, 0x0df4, 0x0e4f, 0x0e5a, 0x0e5b, 0x0f85, 0x10fb, 0x166d, 
+    0x166e, 0x169b, 0x169c, 0x17dc, 0x2045, 0x2046, 0x207d, 0x207e, 0x208d, 
+    0x208e, 0x2329, 0x232a, 0x3030, 0x30fb, 0xfd3e, 0xfd3f, 0xfe63, 0xfe68, 
+    0xfe6a, 0xfe6b, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3f, 0xff5b, 0xff5d
+};
+
+#define NUM_PUNCT_CHAR (sizeof(punctCharTable)/sizeof(chr))
+
+/* Unicode: white space characters */
+
+static crange spaceRangeTable[] = {
+    {0x0009, 0x000d}, {0x2000, 0x200b}
+};
+
+#define NUM_SPACE_RANGE (sizeof(spaceRangeTable)/sizeof(crange))
+
+static chr spaceCharTable[] = {
+    0x0020, 0x00a0, 0x1680, 0x2028, 0x2029, 0x202f, 0x3000
+};
+
+#define NUM_SPACE_CHAR (sizeof(spaceCharTable)/sizeof(chr))
+
+/* Unicode: lowercase characters */
+
+static crange lowerRangeTable[] = {
+    {0x0061, 0x007a}, {0x00df, 0x00f6}, {0x00f8, 0x00ff}, {0x017e, 0x0180}, 
+    {0x0199, 0x019b}, {0x01bd, 0x01bf}, {0x0250, 0x02ad}, {0x03ac, 0x03ce}, 
+    {0x03d5, 0x03d7}, {0x03ef, 0x03f3}, {0x0430, 0x045f}, {0x0561, 0x0587}, 
+    {0x1e95, 0x1e9b}, {0x1f00, 0x1f07}, {0x1f10, 0x1f15}, {0x1f20, 0x1f27}, 
+    {0x1f30, 0x1f37}, {0x1f40, 0x1f45}, {0x1f50, 0x1f57}, {0x1f60, 0x1f67}, 
+    {0x1f70, 0x1f7d}, {0x1f80, 0x1f87}, {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7}, 
+    {0x1fb0, 0x1fb4}, {0x1fc2, 0x1fc4}, {0x1fd0, 0x1fd3}, {0x1fe0, 0x1fe7}, 
+    {0x1ff2, 0x1ff4}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xff41, 0xff5a}
+};
+
+#define NUM_LOWER_RANGE (sizeof(lowerRangeTable)/sizeof(crange))
+
+static chr lowerCharTable[] = {
+    0x00aa, 0x00b5, 0x00ba, 0x0101, 0x0103, 0x0105, 0x0107, 0x0109, 0x010b, 
+    0x010d, 0x010f, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011b, 0x011d, 
+    0x011f, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012b, 0x012d, 0x012f, 
+    0x0131, 0x0133, 0x0135, 0x0137, 0x0138, 0x013a, 0x013c, 0x013e, 0x0140, 
+    0x0142, 0x0144, 0x0146, 0x0148, 0x0149, 0x014b, 0x014d, 0x014f, 0x0151, 
+    0x0153, 0x0155, 0x0157, 0x0159, 0x015b, 0x015d, 0x015f, 0x0161, 0x0163, 
+    0x0165, 0x0167, 0x0169, 0x016b, 0x016d, 0x016f, 0x0171, 0x0173, 0x0175, 
+    0x0177, 0x017a, 0x017c, 0x0183, 0x0185, 0x0188, 0x018c, 0x018d, 0x0192, 
+    0x0195, 0x019e, 0x01a1, 0x01a3, 0x01a5, 0x01a8, 0x01aa, 0x01ab, 0x01ad, 
+    0x01b0, 0x01b4, 0x01b6, 0x01b9, 0x01ba, 0x01c6, 0x01c9, 0x01cc, 0x01ce, 
+    0x01d0, 0x01d2, 0x01d4, 0x01d6, 0x01d8, 0x01da, 0x01dc, 0x01dd, 0x01df, 
+    0x01e1, 0x01e3, 0x01e5, 0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, 0x01f0, 
+    0x01f3, 0x01f5, 0x01f9, 0x01fb, 0x01fd, 0x01ff, 0x0201, 0x0203, 0x0205, 
+    0x0207, 0x0209, 0x020b, 0x020d, 0x020f, 0x0211, 0x0213, 0x0215, 0x0217, 
+    0x0219, 0x021b, 0x021d, 0x021f, 0x0223, 0x0225, 0x0227, 0x0229, 0x022b, 
+    0x022d, 0x022f, 0x0231, 0x0233, 0x0390, 0x03d0, 0x03d1, 0x03db, 0x03dd, 
+    0x03df, 0x03e1, 0x03e3, 0x03e5, 0x03e7, 0x03e9, 0x03eb, 0x03ed, 0x03f5, 
+    0x0461, 0x0463, 0x0465, 0x0467, 0x0469, 0x046b, 0x046d, 0x046f, 0x0471, 
+    0x0473, 0x0475, 0x0477, 0x0479, 0x047b, 0x047d, 0x047f, 0x0481, 0x048d, 
+    0x048f, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049b, 0x049d, 0x049f, 
+    0x04a1, 0x04a3, 0x04a5, 0x04a7, 0x04a9, 0x04ab, 0x04ad, 0x04af, 0x04b1, 
+    0x04b3, 0x04b5, 0x04b7, 0x04b9, 0x04bb, 0x04bd, 0x04bf, 0x04c2, 0x04c4, 
+    0x04c8, 0x04cc, 0x04d1, 0x04d3, 0x04d5, 0x04d7, 0x04d9, 0x04db, 0x04dd, 
+    0x04df, 0x04e1, 0x04e3, 0x04e5, 0x04e7, 0x04e9, 0x04eb, 0x04ed, 0x04ef, 
+    0x04f1, 0x04f3, 0x04f5, 0x04f9, 0x1e01, 0x1e03, 0x1e05, 0x1e07, 0x1e09, 
+    0x1e0b, 0x1e0d, 0x1e0f, 0x1e11, 0x1e13, 0x1e15, 0x1e17, 0x1e19, 0x1e1b, 
+    0x1e1d, 0x1e1f, 0x1e21, 0x1e23, 0x1e25, 0x1e27, 0x1e29, 0x1e2b, 0x1e2d, 
+    0x1e2f, 0x1e31, 0x1e33, 0x1e35, 0x1e37, 0x1e39, 0x1e3b, 0x1e3d, 0x1e3f, 
+    0x1e41, 0x1e43, 0x1e45, 0x1e47, 0x1e49, 0x1e4b, 0x1e4d, 0x1e4f, 0x1e51, 
+    0x1e53, 0x1e55, 0x1e57, 0x1e59, 0x1e5b, 0x1e5d, 0x1e5f, 0x1e61, 0x1e63, 
+    0x1e65, 0x1e67, 0x1e69, 0x1e6b, 0x1e6d, 0x1e6f, 0x1e71, 0x1e73, 0x1e75, 
+    0x1e77, 0x1e79, 0x1e7b, 0x1e7d, 0x1e7f, 0x1e81, 0x1e83, 0x1e85, 0x1e87, 
+    0x1e89, 0x1e8b, 0x1e8d, 0x1e8f, 0x1e91, 0x1e93, 0x1ea1, 0x1ea3, 0x1ea5, 
+    0x1ea7, 0x1ea9, 0x1eab, 0x1ead, 0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7, 
+    0x1eb9, 0x1ebb, 0x1ebd, 0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x1ec9, 
+    0x1ecb, 0x1ecd, 0x1ecf, 0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9, 0x1edb, 
+    0x1edd, 0x1edf, 0x1ee1, 0x1ee3, 0x1ee5, 0x1ee7, 0x1ee9, 0x1eeb, 0x1eed, 
+    0x1eef, 0x1ef1, 0x1ef3, 0x1ef5, 0x1ef7, 0x1ef9, 0x1fb6, 0x1fb7, 0x1fbe, 
+    0x1fc6, 0x1fc7, 0x1fd6, 0x1fd7, 0x1ff6, 0x1ff7, 0x207f, 0x210a, 0x210e, 
+    0x210f, 0x2113, 0x212f, 0x2134, 0x2139
+};
+
+#define NUM_LOWER_CHAR (sizeof(lowerCharTable)/sizeof(chr))
+
+/* Unicode: uppercase characters */
+
+static crange upperRangeTable[] = {
+    {0x0041, 0x005a}, {0x00c0, 0x00d6}, {0x00d8, 0x00de}, {0x0189, 0x018b}, 
+    {0x018e, 0x0191}, {0x0196, 0x0198}, {0x01b1, 0x01b3}, {0x01f6, 0x01f8}, 
+    {0x0388, 0x038a}, {0x0391, 0x03a1}, {0x03a3, 0x03ab}, {0x03d2, 0x03d4}, 
+    {0x0400, 0x042f}, {0x0531, 0x0556}, {0x10a0, 0x10c5}, {0x1f08, 0x1f0f}, 
+    {0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d}, 
+    {0x1f68, 0x1f6f}, {0x1fb8, 0x1fbb}, {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb}, 
+    {0x1fe8, 0x1fec}, {0x1ff8, 0x1ffb}, {0x210b, 0x210d}, {0x2110, 0x2112}, 
+    {0x2119, 0x211d}, {0x212a, 0x212d}, {0xff21, 0xff3a}
+};
+
+#define NUM_UPPER_RANGE (sizeof(upperRangeTable)/sizeof(crange))
+
+static chr upperCharTable[] = {
+    0x0100, 0x0102, 0x0104, 0x0106, 0x0108, 0x010a, 0x010c, 0x010e, 0x0110, 
+    0x0112, 0x0114, 0x0116, 0x0118, 0x011a, 0x011c, 0x011e, 0x0120, 0x0122, 
+    0x0124, 0x0126, 0x0128, 0x012a, 0x012c, 0x012e, 0x0130, 0x0132, 0x0134, 
+    0x0136, 0x0139, 0x013b, 0x013d, 0x013f, 0x0141, 0x0143, 0x0145, 0x0147, 
+    0x014a, 0x014c, 0x014e, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158, 0x015a, 
+    0x015c, 0x015e, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016a, 0x016c, 
+    0x016e, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179, 0x017b, 0x017d, 
+    0x0181, 0x0182, 0x0184, 0x0186, 0x0187, 0x0193, 0x0194, 0x019c, 0x019d, 
+    0x019f, 0x01a0, 0x01a2, 0x01a4, 0x01a6, 0x01a7, 0x01a9, 0x01ac, 0x01ae, 
+    0x01af, 0x01b5, 0x01b7, 0x01b8, 0x01bc, 0x01c4, 0x01c7, 0x01ca, 0x01cd, 
+    0x01cf, 0x01d1, 0x01d3, 0x01d5, 0x01d7, 0x01d9, 0x01db, 0x01de, 0x01e0, 
+    0x01e2, 0x01e4, 0x01e6, 0x01e8, 0x01ea, 0x01ec, 0x01ee, 0x01f1, 0x01f4, 
+    0x01fa, 0x01fc, 0x01fe, 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a, 
+    0x020c, 0x020e, 0x0210, 0x0212, 0x0214, 0x0216, 0x0218, 0x021a, 0x021c, 
+    0x021e, 0x0222, 0x0224, 0x0226, 0x0228, 0x022a, 0x022c, 0x022e, 0x0230, 
+    0x0232, 0x0386, 0x038c, 0x038e, 0x038f, 0x03da, 0x03dc, 0x03de, 0x03e0, 
+    0x03e2, 0x03e4, 0x03e6, 0x03e8, 0x03ea, 0x03ec, 0x03ee, 0x03f4, 0x0460, 
+    0x0462, 0x0464, 0x0466, 0x0468, 0x046a, 0x046c, 0x046e, 0x0470, 0x0472, 
+    0x0474, 0x0476, 0x0478, 0x047a, 0x047c, 0x047e, 0x0480, 0x048c, 0x048e, 
+    0x0490, 0x0492, 0x0494, 0x0496, 0x0498, 0x049a, 0x049c, 0x049e, 0x04a0, 
+    0x04a2, 0x04a4, 0x04a6, 0x04a8, 0x04aa, 0x04ac, 0x04ae, 0x04b0, 0x04b2, 
+    0x04b4, 0x04b6, 0x04b8, 0x04ba, 0x04bc, 0x04be, 0x04c0, 0x04c1, 0x04c3, 
+    0x04c7, 0x04cb, 0x04d0, 0x04d2, 0x04d4, 0x04d6, 0x04d8, 0x04da, 0x04dc, 
+    0x04de, 0x04e0, 0x04e2, 0x04e4, 0x04e6, 0x04e8, 0x04ea, 0x04ec, 0x04ee, 
+    0x04f0, 0x04f2, 0x04f4, 0x04f8, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08, 
+    0x1e0a, 0x1e0c, 0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, 0x1e18, 0x1e1a, 
+    0x1e1c, 0x1e1e, 0x1e20, 0x1e22, 0x1e24, 0x1e26, 0x1e28, 0x1e2a, 0x1e2c, 
+    0x1e2e, 0x1e30, 0x1e32, 0x1e34, 0x1e36, 0x1e38, 0x1e3a, 0x1e3c, 0x1e3e, 
+    0x1e40, 0x1e42, 0x1e44, 0x1e46, 0x1e48, 0x1e4a, 0x1e4c, 0x1e4e, 0x1e50, 
+    0x1e52, 0x1e54, 0x1e56, 0x1e58, 0x1e5a, 0x1e5c, 0x1e5e, 0x1e60, 0x1e62, 
+    0x1e64, 0x1e66, 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70, 0x1e72, 0x1e74, 
+    0x1e76, 0x1e78, 0x1e7a, 0x1e7c, 0x1e7e, 0x1e80, 0x1e82, 0x1e84, 0x1e86, 
+    0x1e88, 0x1e8a, 0x1e8c, 0x1e8e, 0x1e90, 0x1e92, 0x1e94, 0x1ea0, 0x1ea2, 
+    0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac, 0x1eae, 0x1eb0, 0x1eb2, 0x1eb4, 
+    0x1eb6, 0x1eb8, 0x1eba, 0x1ebc, 0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6, 
+    0x1ec8, 0x1eca, 0x1ecc, 0x1ece, 0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8, 
+    0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2, 0x1ee4, 0x1ee6, 0x1ee8, 0x1eea, 
+    0x1eec, 0x1eee, 0x1ef0, 0x1ef2, 0x1ef4, 0x1ef6, 0x1ef8, 0x1f59, 0x1f5b, 
+    0x1f5d, 0x1f5f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2130, 
+    0x2131, 0x2133
+};
+
+#define NUM_UPPER_CHAR (sizeof(upperCharTable)/sizeof(chr))
+
+/* Unicode: unicode print characters excluding space */
+
+static crange graphRangeTable[] = {
+    {0x0021, 0x007e}, {0x00a0, 0x011f}, {0x0121, 0x021f}, {0x0222, 0x0233}, 
+    {0x0250, 0x02ad}, {0x02b0, 0x02ee}, {0x0300, 0x031f}, {0x0321, 0x034e}, 
+    {0x0360, 0x0362}, {0x0384, 0x038a}, {0x038e, 0x03a1}, {0x03a3, 0x03ce}, 
+    {0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x041f}, {0x0421, 0x0486}, 
+    {0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0559, 0x055f}, 
+    {0x0561, 0x0587}, {0x0591, 0x05a1}, {0x05a3, 0x05b9}, {0x05bb, 0x05c4}, 
+    {0x05d0, 0x05ea}, {0x05f0, 0x05f4}, {0x0621, 0x063a}, {0x0640, 0x0655}, 
+    {0x0660, 0x066d}, {0x0670, 0x06ed}, {0x06f0, 0x06fe}, {0x0700, 0x070d}, 
+    {0x0710, 0x071f}, {0x0721, 0x072c}, {0x0730, 0x074a}, {0x0780, 0x07b0}, 
+    {0x0901, 0x0903}, {0x0905, 0x091f}, {0x0921, 0x0939}, {0x093c, 0x094d}, 
+    {0x0950, 0x0954}, {0x0958, 0x0970}, {0x0981, 0x0983}, {0x0985, 0x098c}, 
+    {0x0993, 0x09a8}, {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09be, 0x09c4}, 
+    {0x09cb, 0x09cd}, {0x09df, 0x09e3}, {0x09e6, 0x09fa}, {0x0a05, 0x0a0a}, 
+    {0x0a13, 0x0a1f}, {0x0a21, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a3e, 0x0a42}, 
+    {0x0a4b, 0x0a4d}, {0x0a59, 0x0a5c}, {0x0a66, 0x0a74}, {0x0a81, 0x0a83}, 
+    {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0}, 
+    {0x0ab5, 0x0ab9}, {0x0abc, 0x0ac5}, {0x0ac7, 0x0ac9}, {0x0acb, 0x0acd}, 
+    {0x0ae6, 0x0aef}, {0x0b01, 0x0b03}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b1f}, 
+    {0x0b21, 0x0b28}, {0x0b2a, 0x0b30}, {0x0b36, 0x0b39}, {0x0b3c, 0x0b43}, 
+    {0x0b4b, 0x0b4d}, {0x0b5f, 0x0b61}, {0x0b66, 0x0b70}, {0x0b85, 0x0b8a}, 
+    {0x0b8e, 0x0b90}, {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, 
+    {0x0bb7, 0x0bb9}, {0x0bbe, 0x0bc2}, {0x0bc6, 0x0bc8}, {0x0bca, 0x0bcd}, 
+    {0x0be7, 0x0bf2}, {0x0c01, 0x0c03}, {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, 
+    {0x0c12, 0x0c1f}, {0x0c21, 0x0c28}, {0x0c2a, 0x0c33}, {0x0c35, 0x0c39}, 
+    {0x0c3e, 0x0c44}, {0x0c46, 0x0c48}, {0x0c4a, 0x0c4d}, {0x0c66, 0x0c6f}, 
+    {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8}, {0x0caa, 0x0cb3}, 
+    {0x0cb5, 0x0cb9}, {0x0cbe, 0x0cc4}, {0x0cc6, 0x0cc8}, {0x0cca, 0x0ccd}, 
+    {0x0ce6, 0x0cef}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10}, {0x0d12, 0x0d1f}, 
+    {0x0d21, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d3e, 0x0d43}, {0x0d46, 0x0d48}, 
+    {0x0d4a, 0x0d4d}, {0x0d66, 0x0d6f}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1}, 
+    {0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0dcf, 0x0dd4}, {0x0dd8, 0x0ddf}, 
+    {0x0df2, 0x0df4}, {0x0e01, 0x0e1f}, {0x0e21, 0x0e3a}, {0x0e3f, 0x0e5b}, 
+    {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb9}, 
+    {0x0ebb, 0x0ebd}, {0x0ec0, 0x0ec4}, {0x0ec8, 0x0ecd}, {0x0ed0, 0x0ed9}, 
+    {0x0f00, 0x0f1f}, {0x0f21, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f71, 0x0f8b}, 
+    {0x0f90, 0x0f97}, {0x0f99, 0x0fbc}, {0x0fbe, 0x0fcc}, {0x1000, 0x101f}, 
+    {0x1023, 0x1027}, {0x102c, 0x1032}, {0x1036, 0x1039}, {0x1040, 0x1059}, 
+    {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x111f}, {0x1121, 0x1159}, 
+    {0x115f, 0x11a2}, {0x11a8, 0x11f9}, {0x1200, 0x1206}, {0x1208, 0x121f}, 
+    {0x1221, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256}, {0x125a, 0x125d}, 
+    {0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b2, 0x12b5}, 
+    {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce}, {0x12d0, 0x12d6}, 
+    {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315}, {0x1318, 0x131e}, 
+    {0x1321, 0x1346}, {0x1348, 0x135a}, {0x1361, 0x137c}, {0x13a0, 0x13f4}, 
+    {0x1401, 0x141f}, {0x1421, 0x151f}, {0x1521, 0x161f}, {0x1621, 0x1676}, 
+    {0x1680, 0x169c}, {0x16a0, 0x16f0}, {0x1780, 0x17dc}, {0x17e0, 0x17e9}, 
+    {0x1800, 0x180a}, {0x1810, 0x1819}, {0x1821, 0x1877}, {0x1880, 0x18a9}, 
+    {0x1e00, 0x1e1f}, {0x1e21, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, 
+    {0x1f18, 0x1f1d}, {0x1f21, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, 
+    {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3}, 
+    {0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe}, 
+    {0x2000, 0x200b}, {0x2010, 0x201f}, {0x2021, 0x2029}, {0x202f, 0x2046}, 
+    {0x2048, 0x204d}, {0x2074, 0x208e}, {0x20a0, 0x20af}, {0x20d0, 0x20e3}, 
+    {0x2100, 0x211f}, {0x2121, 0x213a}, {0x2153, 0x2183}, {0x2190, 0x21f3}, 
+    {0x2200, 0x221f}, {0x2221, 0x22f1}, {0x2300, 0x231f}, {0x2321, 0x237b}, 
+    {0x237d, 0x239a}, {0x2400, 0x241f}, {0x2421, 0x2426}, {0x2440, 0x244a}, 
+    {0x2460, 0x24ea}, {0x2500, 0x251f}, {0x2521, 0x2595}, {0x25a0, 0x25f7}, 
+    {0x2600, 0x2613}, {0x2619, 0x261f}, {0x2621, 0x2671}, {0x2701, 0x2704}, 
+    {0x2706, 0x2709}, {0x270c, 0x271f}, {0x2721, 0x2727}, {0x2729, 0x274b}, 
+    {0x274f, 0x2752}, {0x2758, 0x275e}, {0x2761, 0x2767}, {0x2776, 0x2794}, 
+    {0x2798, 0x27af}, {0x27b1, 0x27be}, {0x2800, 0x281f}, {0x2821, 0x28ff}, 
+    {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2f1f}, {0x2f21, 0x2fd5}, 
+    {0x2ff0, 0x2ffb}, {0x3000, 0x301f}, {0x3021, 0x303a}, {0x3041, 0x3094}, 
+    {0x3099, 0x309e}, {0x30a1, 0x30fe}, {0x3105, 0x311f}, {0x3121, 0x312c}, 
+    {0x3131, 0x318e}, {0x3190, 0x31b7}, {0x3200, 0x321c}, {0x3221, 0x3243}, 
+    {0x3260, 0x327b}, {0x327f, 0x32b0}, {0x32c0, 0x32cb}, {0x32d0, 0x32fe}, 
+    {0x3300, 0x331f}, {0x3321, 0x3376}, {0x337b, 0x33dd}, {0x33e0, 0x33fe}, 
+    {0x3400, 0x341f}, {0x3421, 0x351f}, {0x3521, 0x361f}, {0x3621, 0x371f}, 
+    {0x3721, 0x381f}, {0x3821, 0x391f}, {0x3921, 0x3a1f}, {0x3a21, 0x3b1f}, 
+    {0x3b21, 0x3c1f}, {0x3c21, 0x3d1f}, {0x3d21, 0x3e1f}, {0x3e21, 0x3f1f}, 
+    {0x3f21, 0x401f}, {0x4021, 0x411f}, {0x4121, 0x421f}, {0x4221, 0x431f}, 
+    {0x4321, 0x441f}, {0x4421, 0x451f}, {0x4521, 0x461f}, {0x4621, 0x471f}, 
+    {0x4721, 0x481f}, {0x4821, 0x491f}, {0x4921, 0x4a1f}, {0x4a21, 0x4b1f}, 
+    {0x4b21, 0x4c1f}, {0x4c21, 0x4d1f}, {0x4d21, 0x4db5}, {0x4e00, 0x4e1f}, 
+    {0x4e21, 0x4f1f}, {0x4f21, 0x501f}, {0x5021, 0x511f}, {0x5121, 0x521f}, 
+    {0x5221, 0x531f}, {0x5321, 0x541f}, {0x5421, 0x551f}, {0x5521, 0x561f}, 
+    {0x5621, 0x571f}, {0x5721, 0x581f}, {0x5821, 0x591f}, {0x5921, 0x5a1f}, 
+    {0x5a21, 0x5b1f}, {0x5b21, 0x5c1f}, {0x5c21, 0x5d1f}, {0x5d21, 0x5e1f}, 
+    {0x5e21, 0x5f1f}, {0x5f21, 0x601f}, {0x6021, 0x611f}, {0x6121, 0x621f}, 
+    {0x6221, 0x631f}, {0x6321, 0x641f}, {0x6421, 0x651f}, {0x6521, 0x661f}, 
+    {0x6621, 0x671f}, {0x6721, 0x681f}, {0x6821, 0x691f}, {0x6921, 0x6a1f}, 
+    {0x6a21, 0x6b1f}, {0x6b21, 0x6c1f}, {0x6c21, 0x6d1f}, {0x6d21, 0x6e1f}, 
+    {0x6e21, 0x6f1f}, {0x6f21, 0x701f}, {0x7021, 0x711f}, {0x7121, 0x721f}, 
+    {0x7221, 0x731f}, {0x7321, 0x741f}, {0x7421, 0x751f}, {0x7521, 0x761f}, 
+    {0x7621, 0x771f}, {0x7721, 0x781f}, {0x7821, 0x791f}, {0x7921, 0x7a1f}, 
+    {0x7a21, 0x7b1f}, {0x7b21, 0x7c1f}, {0x7c21, 0x7d1f}, {0x7d21, 0x7e1f}, 
+    {0x7e21, 0x7f1f}, {0x7f21, 0x801f}, {0x8021, 0x811f}, {0x8121, 0x821f}, 
+    {0x8221, 0x831f}, {0x8321, 0x841f}, {0x8421, 0x851f}, {0x8521, 0x861f}, 
+    {0x8621, 0x871f}, {0x8721, 0x881f}, {0x8821, 0x891f}, {0x8921, 0x8a1f}, 
+    {0x8a21, 0x8b1f}, {0x8b21, 0x8c1f}, {0x8c21, 0x8d1f}, {0x8d21, 0x8e1f}, 
+    {0x8e21, 0x8f1f}, {0x8f21, 0x901f}, {0x9021, 0x911f}, {0x9121, 0x921f}, 
+    {0x9221, 0x931f}, {0x9321, 0x941f}, {0x9421, 0x951f}, {0x9521, 0x961f}, 
+    {0x9621, 0x971f}, {0x9721, 0x981f}, {0x9821, 0x991f}, {0x9921, 0x9a1f}, 
+    {0x9a21, 0x9b1f}, {0x9b21, 0x9c1f}, {0x9c21, 0x9d1f}, {0x9d21, 0x9e1f}, 
+    {0x9e21, 0x9f1f}, {0x9f21, 0x9fa5}, {0xa000, 0xa01f}, {0xa021, 0xa11f}, 
+    {0xa121, 0xa21f}, {0xa221, 0xa31f}, {0xa321, 0xa41f}, {0xa421, 0xa48c}, 
+    {0xa490, 0xa4a1}, {0xa4a4, 0xa4b3}, {0xa4b5, 0xa4c0}, {0xa4c2, 0xa4c4}, 
+    {0xac00, 0xac1f}, {0xac21, 0xad1f}, {0xad21, 0xae1f}, {0xae21, 0xaf1f}, 
+    {0xaf21, 0xb01f}, {0xb021, 0xb11f}, {0xb121, 0xb21f}, {0xb221, 0xb31f}, 
+    {0xb321, 0xb41f}, {0xb421, 0xb51f}, {0xb521, 0xb61f}, {0xb621, 0xb71f}, 
+    {0xb721, 0xb81f}, {0xb821, 0xb91f}, {0xb921, 0xba1f}, {0xba21, 0xbb1f}, 
+    {0xbb21, 0xbc1f}, {0xbc21, 0xbd1f}, {0xbd21, 0xbe1f}, {0xbe21, 0xbf1f}, 
+    {0xbf21, 0xc01f}, {0xc021, 0xc11f}, {0xc121, 0xc21f}, {0xc221, 0xc31f}, 
+    {0xc321, 0xc41f}, {0xc421, 0xc51f}, {0xc521, 0xc61f}, {0xc621, 0xc71f}, 
+    {0xc721, 0xc81f}, {0xc821, 0xc91f}, {0xc921, 0xca1f}, {0xca21, 0xcb1f}, 
+    {0xcb21, 0xcc1f}, {0xcc21, 0xcd1f}, {0xcd21, 0xce1f}, {0xce21, 0xcf1f}, 
+    {0xcf21, 0xd01f}, {0xd021, 0xd11f}, {0xd121, 0xd21f}, {0xd221, 0xd31f}, 
+    {0xd321, 0xd41f}, {0xd421, 0xd51f}, {0xd521, 0xd61f}, {0xd621, 0xd71f}, 
+    {0xd721, 0xd7a3}, {0xf900, 0xf91f}, {0xf921, 0xfa1f}, {0xfa21, 0xfa2d}, 
+    {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb1f}, {0xfb21, 0xfb36}, 
+    {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfc1f}, {0xfc21, 0xfd1f}, 
+    {0xfd21, 0xfd3f}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, 
+    {0xfe21, 0xfe23}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe66}, 
+    {0xfe68, 0xfe6b}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc}, {0xff01, 0xff1f}, 
+    {0xff21, 0xff5e}, {0xff61, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, 
+    {0xffd2, 0xffd7}, {0xffda, 0xffdc}, {0xffe0, 0xffe6}, {0xffe8, 0xffee}, 
+    {0xfffc, 0xffff}
+};
+
+#define NUM_GRAPH_RANGE (sizeof(graphRangeTable)/sizeof(crange))
+
+static chr graphCharTable[] = {
+    0x0374, 0x0375, 0x037a, 0x037e, 0x038c, 0x0488, 0x0489, 0x04c7, 0x04c8, 
+    0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0589, 0x058a, 0x060c, 0x061b, 0x061f, 
+    0x098f, 0x0990, 0x09b2, 0x09bc, 0x09c7, 0x09c8, 0x09d7, 0x09dc, 0x09dd, 
+    0x0a02, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 0x0a39, 
+    0x0a3c, 0x0a47, 0x0a48, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0ad0, 0x0ae0, 
+    0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b47, 0x0b48, 0x0b56, 0x0b57, 0x0b5c, 
+    0x0b5d, 0x0b82, 0x0b83, 0x0b99, 0x0b9a, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3, 
+    0x0ba4, 0x0bd7, 0x0c55, 0x0c56, 0x0c60, 0x0c61, 0x0c82, 0x0c83, 0x0cd5, 
+    0x0cd6, 0x0cde, 0x0ce0, 0x0ce1, 0x0d02, 0x0d03, 0x0d57, 0x0d60, 0x0d61, 
+    0x0d82, 0x0d83, 0x0dbd, 0x0dca, 0x0dd6, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 
+    0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0ec6, 0x0edc, 
+    0x0edd, 0x0fcf, 0x1021, 0x1029, 0x102a, 0x10fb, 0x1248, 0x1258, 0x1288, 
+    0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x2070, 0x274d, 0x2756, 
+    0x303e, 0x303f, 0xa4c6, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74
+};
+
+#define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))
+
+/*
+ *	End of auto-generated Unicode character ranges declarations.
+ */
+
+#define	CH	NOCELT
+
+/*
+ - nmcces - how many distinct MCCEs are there?
+ ^ static int nmcces(struct vars *);
+ */
+static int
+nmcces(v)
+    struct vars *v;			/* context */
+{
+    /*
+     * No multi-character collating elements defined at the moment.
+     */
+    return 0;
+}
+
+/*
+ - nleaders - how many chrs can be first chrs of MCCEs?
+ ^ static int nleaders(struct vars *);
+ */
+static int
+nleaders(v)
+    struct vars *v;			/* context */
+{
+    return 0;
+}
+
+/*
+ - allmcces - return a cvec with all the MCCEs of the locale
+ ^ static struct cvec *allmcces(struct vars *, struct cvec *);
+ */
+static struct cvec *
+allmcces(v, cv)
+    struct vars *v;			/* context */
+    struct cvec *cv;			/* this is supposed to have enough room */
+{
+    return clearcvec(cv);
+}
+
+/*
+ - element - map collating-element name to celt
+ ^ static celt element(struct vars *, chr *, chr *);
+ */
+static celt
+element(v, startp, endp)
+    struct vars *v;			/* context */
+    chr *startp;			/* points to start of name */
+    chr *endp;				/* points just past end of name */
+{
+    struct cname *cn;
+    size_t len;
+    Tcl_DString ds;
+    CONST char *np;
+
+    /* generic:  one-chr names stand for themselves */
+    assert(startp < endp);
+    len = endp - startp;
+    if (len == 1) {
+	return *startp;
+    }
+
+    NOTE(REG_ULOCALE);
+
+    /* search table */
+    Tcl_DStringInit(&ds);
+    np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
+    for (cn=cnames; cn->name!=NULL; cn++) {
+	if (strlen(cn->name)==len && strncmp(cn->name, np, len)==0) {
+	    break;			/* NOTE BREAK OUT */
+	}
+    }
+    Tcl_DStringFree(&ds);
+    if (cn->name != NULL) {
+	return CHR(cn->code);
+    }
+
+    /* couldn't find it */
+    ERR(REG_ECOLLATE);
+    return 0;
+}
+
+/*
+ - range - supply cvec for a range, including legality check
+ ^ static struct cvec *range(struct vars *, celt, celt, int);
+ */
+static struct cvec *
+range(v, a, b, cases)
+    struct vars *v;			/* context */
+    celt a;				/* range start */
+    celt b;				/* range end, might equal a */
+    int cases;				/* case-independent? */
+{
+    int nchrs;
+    struct cvec *cv;
+    celt c, lc, uc, tc;
+
+    if (a != b && !before(a, b)) {
+	ERR(REG_ERANGE);
+	return NULL;
+    }
+
+    if (!cases) {			/* easy version */
+	cv = getcvec(v, 0, 1, 0);
+	NOERRN();
+	addrange(cv, a, b);
+	return cv;
+    }
+
+    /*
+     * When case-independent, it's hard to decide when cvec ranges are
+     * usable, so for now at least, we won't try.  We allocate enough
+     * space for two case variants plus a little extra for the two
+     * title case variants.
+     */
+
+    nchrs = (b - a + 1)*2 + 4;
+
+    cv = getcvec(v, nchrs, 0, 0);
+    NOERRN();
+
+    for (c=a; c<=b; c++) {
+	addchr(cv, c);
+	lc = Tcl_UniCharToLower((chr)c);
+	uc = Tcl_UniCharToUpper((chr)c);
+	tc = Tcl_UniCharToTitle((chr)c);
+	if (c != lc) {
+	    addchr(cv, lc);
+	}
+	if (c != uc) {
+	    addchr(cv, uc);
+	}
+	if (c != tc && tc != uc) {
+	    addchr(cv, tc);
+	}
+    }
+
+    return cv;
+}
+
+/*
+ - before - is celt x before celt y, for purposes of range legality?
+ ^ static int before(celt, celt);
+ */
+static int				/* predicate */
+before(x, y)
+    celt x, y;				/* collating elements */
+{
+    /* trivial because no MCCEs */
+    if (x < y) {
+	return 1;
+    }
+    return 0;
+}
+
+/*
+ - eclass - supply cvec for an equivalence class
+ * Must include case counterparts on request.
+ ^ static struct cvec *eclass(struct vars *, celt, int);
+ */
+static struct cvec *
+eclass(v, c, cases)
+    struct vars *v;			/* context */
+    celt c;				/* Collating element representing
+					 * the equivalence class. */
+    int cases;				/* all cases? */
+{
+    struct cvec *cv;
+
+    /* crude fake equivalence class for testing */
+    if ((v->cflags&REG_FAKE) && c == 'x') {
+	cv = getcvec(v, 4, 0, 0);
+	addchr(cv, (chr)'x');
+	addchr(cv, (chr)'y');
+	if (cases) {
+	    addchr(cv, (chr)'X');
+	    addchr(cv, (chr)'Y');
+	}
+	return cv;
+    }
+
+    /* otherwise, none */
+    if (cases) {
+	return allcases(v, c);
+    }
+    cv = getcvec(v, 1, 0, 0);
+    assert(cv != NULL);
+    addchr(cv, (chr)c);
+    return cv;
+}
+
+/*
+ - cclass - supply cvec for a character class
+ * Must include case counterparts on request.
+ ^ static struct cvec *cclass(struct vars *, chr *, chr *, int);
+ */
+static struct cvec *
+cclass(v, startp, endp, cases)
+    struct vars *v;			/* context */
+    chr *startp;			/* where the name starts */
+    chr *endp;				/* just past the end of the name */
+    int cases;				/* case-independent? */
+{
+    size_t len;
+    struct cvec *cv = NULL;
+    Tcl_DString ds;
+    CONST char *np;
+    char **namePtr;
+    int i, index;
+
+    /*
+     * The following arrays define the valid character class names.
+     */
+
+    static char *classNames[] = {
+	"alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph",
+	"lower", "print", "punct", "space", "upper", "xdigit", NULL
+    };
+
+    enum classes {
+	CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH,
+	CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_XDIGIT
+    };
+    
+
+    /*
+     * Extract the class name
+     */
+
+    len = endp - startp;
+    Tcl_DStringInit(&ds);
+    np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
+
+    /*
+     * Remap lower and upper to alpha if the match is case insensitive.
+     */
+
+    if (cases && len == 5 && (strncmp("lower", np, 5) == 0
+	    || strncmp("upper", np, 5) == 0)) {
+	np = "alpha";
+    }
+
+    /*
+     * Map the name to the corresponding enumerated value.
+     */
+
+    index = -1;
+    for (namePtr=classNames,i=0 ; *namePtr!=NULL ; namePtr++,i++) {
+	if ((strlen(*namePtr) == len) && (strncmp(*namePtr, np, len) == 0)) {
+	    index = i;
+	    break;
+	}
+    }
+    Tcl_DStringInit(&ds);
+    if (index == -1) {
+	ERR(REG_ECTYPE);
+	return NULL;
+    }
+    
+    /*
+     * Now compute the character class contents.
+     */
+
+    switch((enum classes) index) {
+    case CC_PRINT:
+    case CC_ALNUM:
+	cv = getcvec(v, NUM_ALPHA_CHAR, NUM_DIGIT_RANGE + NUM_ALPHA_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
+		addchr(cv, alphaCharTable[i]);
+	    }
+	    for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
+		addrange(cv, alphaRangeTable[i].start,
+			alphaRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
+		addrange(cv, digitRangeTable[i].start,
+			digitRangeTable[i].end);
+	    }
+	}
+	break;
+    case CC_ALPHA:
+	cv = getcvec(v, NUM_ALPHA_CHAR, NUM_ALPHA_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
+		addrange(cv, alphaRangeTable[i].start,
+			alphaRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
+		addchr(cv, alphaCharTable[i]);
+	    }
+	}
+	break;
+    case CC_ASCII:
+	cv = getcvec(v, 0, 1, 0);
+	if (cv) {
+	    addrange(cv, 0, 0x7f);
+	}
+	break;
+    case CC_BLANK:
+	cv = getcvec(v, 2, 0, 0);
+	addchr(cv, '\t');
+	addchr(cv, ' ');
+	break;
+    case CC_CNTRL:
+	cv = getcvec(v, 0, 2, 0);
+	addrange(cv, 0x0, 0x1f);
+	addrange(cv, 0x7f, 0x9f);
+	break;
+    case CC_DIGIT:
+	cv = getcvec(v, 0, NUM_DIGIT_RANGE, 0);
+	if (cv) {	
+	    for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
+		addrange(cv, digitRangeTable[i].start,
+			digitRangeTable[i].end);
+	    }
+	}
+	break;
+    case CC_PUNCT:
+	cv = getcvec(v, NUM_PUNCT_CHAR, NUM_PUNCT_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_PUNCT_RANGE ; i++) {
+		addrange(cv, punctRangeTable[i].start,
+			punctRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_PUNCT_CHAR ; i++) {
+		addchr(cv, punctCharTable[i]);
+	    }
+	}
+	break;
+    case CC_XDIGIT:
+	/*
+	 * This is a 3 instead of (NUM_DIGIT_RANGE+2) because I've no
+	 * idea how to define the digits 'a' through 'f' in
+	 * non-western locales.  The concept is quite possibly non
+	 * portable, or only used in contextx where the characters
+	 * used would be the western ones anyway!  Whatever is
+	 * actually the case, the number of ranges is fixed (until
+	 * someone comes up with a better arrangement!)
+	 */
+	cv = getcvec(v, 0, 3, 0);
+	if (cv) {	
+	    addrange(cv, '0', '9');
+	    addrange(cv, 'a', 'f');
+	    addrange(cv, 'A', 'F');
+	}
+	break;
+    case CC_SPACE:
+	cv = getcvec(v, NUM_SPACE_CHAR, NUM_SPACE_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_SPACE_RANGE ; i++) {
+		addrange(cv, spaceRangeTable[i].start,
+			spaceRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_SPACE_CHAR ; i++) {
+		addchr(cv, spaceCharTable[i]);
+	    }
+	}
+	break;
+    case CC_LOWER:
+	cv  = getcvec(v, NUM_LOWER_CHAR, NUM_LOWER_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_LOWER_RANGE ; i++) {
+		addrange(cv, lowerRangeTable[i].start,
+			lowerRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_LOWER_CHAR ; i++) {
+		addchr(cv, lowerCharTable[i]);
+	    }
+	}
+	break;
+    case CC_UPPER:
+	cv  = getcvec(v, NUM_UPPER_CHAR, NUM_UPPER_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_UPPER_RANGE ; i++) {
+		addrange(cv, upperRangeTable[i].start,
+			upperRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_UPPER_CHAR ; i++) {
+		addchr(cv, upperCharTable[i]);
+	    }
+	}
+	break;
+    case CC_GRAPH:
+	cv  = getcvec(v, NUM_GRAPH_CHAR, NUM_GRAPH_RANGE, 0);
+	if (cv) {
+	    for (i=0 ; i<NUM_GRAPH_RANGE ; i++) {
+		addrange(cv, graphRangeTable[i].start,
+			graphRangeTable[i].end);
+	    }
+	    for (i=0 ; i<NUM_GRAPH_CHAR ; i++) {
+		addchr(cv, graphCharTable[i]);
+	    }
+	}
+	break;
+    }
+    if (cv == NULL) {
+	ERR(REG_ESPACE);
+    }
+    return cv;
+}
+
+/*
+ - allcases - supply cvec for all case counterparts of a chr (including itself)
+ * This is a shortcut, preferably an efficient one, for simple characters;
+ * messy cases are done via range().
+ ^ static struct cvec *allcases(struct vars *, pchr);
+ */
+static struct cvec *
+allcases(v, pc)
+    struct vars *v;			/* context */
+    pchr pc;				/* character to get case equivs of */
+{
+    struct cvec *cv;
+    chr c = (chr)pc;
+    chr lc, uc, tc;
+
+    lc = Tcl_UniCharToLower((chr)c);
+    uc = Tcl_UniCharToUpper((chr)c);
+    tc = Tcl_UniCharToTitle((chr)c);
+
+    if (tc != uc) {
+	cv = getcvec(v, 3, 0, 0);
+	addchr(cv, tc);
+    } else {
+	cv = getcvec(v, 2, 0, 0);
+    }
+    addchr(cv, lc);
+    if (lc != uc) {
+	addchr(cv, uc);
+    }
+    return cv;
+}
+
+/*
+ - cmp - chr-substring compare
+ * Backrefs need this.  It should preferably be efficient.
+ * Note that it does not need to report anything except equal/unequal.
+ * Note also that the length is exact, and the comparison should not
+ * stop at embedded NULs!
+ ^ static int cmp(CONST chr *, CONST chr *, size_t);
+ */
+static int				/* 0 for equal, nonzero for unequal */
+cmp(x, y, len)
+    CONST chr *x, *y;			/* strings to compare */
+    size_t len;				/* exact length of comparison */
+{
+    return memcmp(VS(x), VS(y), len*sizeof(chr));
+}
+
+/*
+ - casecmp - case-independent chr-substring compare
+ * REG_ICASE backrefs need this.  It should preferably be efficient.
+ * Note that it does not need to report anything except equal/unequal.
+ * Note also that the length is exact, and the comparison should not
+ * stop at embedded NULs!
+ ^ static int casecmp(CONST chr *, CONST chr *, size_t);
+ */
+static int				/* 0 for equal, nonzero for unequal */
+casecmp(x, y, len)
+    CONST chr *x, *y;			/* strings to compare */
+    size_t len;				/* exact length of comparison */
+{
+    for (; len > 0; len--, x++, y++) {
+	if ((*x!=*y) && (Tcl_UniCharToLower(*x) != Tcl_UniCharToLower(*y))) {
+	    return 1;
+	}
+    }
+    return 0;
+}

src/regex/regcustom.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* headers if any */
+#include "tclInt.h"
+
+/* overrides for regguts.h definitions, if any */
+#define	FUNCPTR(name, args)	(*name) _ANSI_ARGS_(args)
+#define	MALLOC(n)		ckalloc(n)
+#define	FREE(p)			ckfree(VS(p))
+#define	REALLOC(p,n)		ckrealloc(VS(p),n)
+
+
+
+/*
+ * Do not insert extras between the "begin" and "end" lines -- this
+ * chunk is automatically extracted to be fitted into regex.h.
+ */
+/* --- begin --- */
+/* ensure certain things don't sneak in from system headers */
+#ifdef __REG_WIDE_T
+#undef __REG_WIDE_T
+#endif
+#ifdef __REG_WIDE_COMPILE
+#undef __REG_WIDE_COMPILE
+#endif
+#ifdef __REG_WIDE_EXEC
+#undef __REG_WIDE_EXEC
+#endif
+#ifdef __REG_REGOFF_T
+#undef __REG_REGOFF_T
+#endif
+#ifdef __REG_VOID_T
+#undef __REG_VOID_T
+#endif
+#ifdef __REG_CONST
+#undef __REG_CONST
+#endif
+#ifdef __REG_NOFRONT
+#undef __REG_NOFRONT
+#endif
+#ifdef __REG_NOCHAR
+#undef __REG_NOCHAR
+#endif
+/* interface types */
+#define	__REG_WIDE_T	Tcl_UniChar
+#define	__REG_REGOFF_T	long	/* not really right, but good enough... */
+#define	__REG_VOID_T	VOID
+#define	__REG_CONST	CONST
+/* names and declarations */
+#define	__REG_WIDE_COMPILE	TclReComp
+#define	__REG_WIDE_EXEC		TclReExec
+#define	__REG_NOFRONT		/* don't want regcomp() and regexec() */
+#define	__REG_NOCHAR		/* or the char versions */
+#define	regfree		TclReFree
+#define	regerror	TclReError
+/* --- end --- */
+
+
+
+/* internal character type and related */
+typedef Tcl_UniChar chr;	/* the type itself */
+typedef int pchr;		/* what it promotes to */
+typedef unsigned uchr;		/* unsigned type that will hold a chr */
+typedef int celt;		/* type to hold chr, MCCE number, or NOCELT */
+#define	NOCELT	(-1)		/* celt value which is not valid chr or MCCE */
+#define	CHR(c)	(UCHAR(c))	/* turn char literal into chr literal */
+#define	DIGITVAL(c)	((c)-'0')	/* turn chr digit into its value */
+#if TCL_UTF_MAX > 3
+#define	CHRBITS	32		/* bits in a chr; must not use sizeof */
+#define	CHR_MIN	0x00000000	/* smallest and largest chr; the value */
+#define	CHR_MAX	0xffffffff	/*  CHR_MAX-CHR_MIN+1 should fit in uchr */
+#else
+#define	CHRBITS	16		/* bits in a chr; must not use sizeof */
+#define	CHR_MIN	0x0000		/* smallest and largest chr; the value */
+#define	CHR_MAX	0xffff		/*  CHR_MAX-CHR_MIN+1 should fit in uchr */
+#endif
+
+/* functions operating on chr */
+#define	iscalnum(x)	Tcl_UniCharIsAlnum(x)
+#define	iscalpha(x)	Tcl_UniCharIsAlpha(x)
+#define	iscdigit(x)	Tcl_UniCharIsDigit(x)
+#define	iscspace(x)	Tcl_UniCharIsSpace(x)
+
+/* name the external functions */
+#define	compile		TclReComp
+#define	exec		TclReExec
+
+/* enable/disable debugging code (by whether REG_DEBUG is defined or not) */
+#if 0		/* no debug unless requested by makefile */
+#define	REG_DEBUG	/* */
+#endif
+
+/* and pick up the standard header */
+#include "regex.h"

src/regex/rege_dfa.c

@@ -0,0 +1,677 @@
+/*
+ * DFA routines
+ * This file is #included by regexec.c.
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*
+ - longest - longest-preferred matching engine
+ ^ static chr *longest(struct vars *, struct dfa *, chr *, chr *, int *);
+ */
+static chr *			/* endpoint, or NULL */
+longest(v, d, start, stop, hitstopp)
+struct vars *v;			/* used only for debug and exec flags */
+struct dfa *d;
+chr *start;			/* where the match should start */
+chr *stop;			/* match must end at or before here */
+int *hitstopp;			/* record whether hit v->stop, if non-NULL */
+{
+	chr *cp;
+	chr *realstop = (stop == v->stop) ? stop : stop + 1;
+	color co;
+	struct sset *css;
+	struct sset *ss;
+	chr *post;
+	int i;
+	struct colormap *cm = d->cm;
+
+	/* initialize */
+	css = initialize(v, d, start);
+	cp = start;
+	if (hitstopp != NULL)
+		*hitstopp = 0;
+
+	/* startup */
+	FDEBUG(("+++ startup +++\n"));
+	if (cp == v->start) {
+		co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1];
+		FDEBUG(("color %ld\n", (long)co));
+	} else {
+		co = GETCOLOR(cm, *(cp - 1));
+		FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co));
+	}
+	css = miss(v, d, css, co, cp, start);
+	if (css == NULL)
+		return NULL;
+	css->lastseen = cp;
+
+	/* main loop */
+	if (v->eflags&REG_FTRACE)
+		while (cp < realstop) {
+			FDEBUG(("+++ at c%d +++\n", css - d->ssets));
+			co = GETCOLOR(cm, *cp);
+			FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co));
+			ss = css->outs[co];
+			if (ss == NULL) {
+				ss = miss(v, d, css, co, cp+1, start);
+				if (ss == NULL)
+					break;	/* NOTE BREAK OUT */
+			}
+			cp++;
+			ss->lastseen = cp;
+			css = ss;
+		}
+	else
+		while (cp < realstop) {
+			co = GETCOLOR(cm, *cp);
+			ss = css->outs[co];
+			if (ss == NULL) {
+				ss = miss(v, d, css, co, cp+1, start);
+				if (ss == NULL)
+					break;	/* NOTE BREAK OUT */
+			}
+			cp++;
+			ss->lastseen = cp;
+			css = ss;
+		}
+
+	/* shutdown */
+	FDEBUG(("+++ shutdown at c%d +++\n", css - d->ssets));
+	if (cp == v->stop && stop == v->stop) {
+		if (hitstopp != NULL)
+			*hitstopp = 1;
+		co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1];
+		FDEBUG(("color %ld\n", (long)co));
+		ss = miss(v, d, css, co, cp, start);
+		/* special case:  match ended at eol? */
+		if (ss != NULL && (ss->flags&POSTSTATE))
+			return cp;
+		else if (ss != NULL)
+			ss->lastseen = cp;	/* to be tidy */
+	}
+
+	/* find last match, if any */
+	post = d->lastpost;
+	for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
+		if ((ss->flags&POSTSTATE) && post != ss->lastseen &&
+					(post == NULL || post < ss->lastseen))
+			post = ss->lastseen;
+	if (post != NULL)		/* found one */
+		return post - 1;
+
+	return NULL;
+}
+
+/*
+ - shortest - shortest-preferred matching engine
+ ^ static chr *shortest(struct vars *, struct dfa *, chr *, chr *, chr *,
+ ^ 	chr **, int *);
+ */
+static chr *			/* endpoint, or NULL */
+shortest(v, d, start, min, max, coldp, hitstopp)
+struct vars *v;
+struct dfa *d;
+chr *start;			/* where the match should start */
+chr *min;			/* match must end at or after here */
+chr *max;			/* match must end at or before here */
+chr **coldp;			/* store coldstart pointer here, if nonNULL */
+int *hitstopp;			/* record whether hit v->stop, if non-NULL */
+{
+	chr *cp;
+	chr *realmin = (min == v->stop) ? min : min + 1;
+	chr *realmax = (max == v->stop) ? max : max + 1;
+	color co;
+	struct sset *css;
+	struct sset *ss;
+	struct colormap *cm = d->cm;
+
+	/* initialize */
+	css = initialize(v, d, start);
+	cp = start;
+	if (hitstopp != NULL)
+		*hitstopp = 0;
+
+	/* startup */
+	FDEBUG(("--- startup ---\n"));
+	if (cp == v->start) {
+		co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1];
+		FDEBUG(("color %ld\n", (long)co));
+	} else {
+		co = GETCOLOR(cm, *(cp - 1));
+		FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co));
+	}
+	css = miss(v, d, css, co, cp, start);
+	if (css == NULL)
+		return NULL;
+	css->lastseen = cp;
+	ss = css;
+
+	/* main loop */
+	if (v->eflags&REG_FTRACE)
+		while (cp < realmax) {
+			FDEBUG(("--- at c%d ---\n", css - d->ssets));
+			co = GETCOLOR(cm, *cp);
+			FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co));
+			ss = css->outs[co];
+			if (ss == NULL) {
+				ss = miss(v, d, css, co, cp+1, start);
+				if (ss == NULL)
+					break;	/* NOTE BREAK OUT */
+			}
+			cp++;
+			ss->lastseen = cp;
+			css = ss;
+			if ((ss->flags&POSTSTATE) && cp >= realmin)
+				break;		/* NOTE BREAK OUT */
+		}
+	else
+		while (cp < realmax) {
+			co = GETCOLOR(cm, *cp);
+			ss = css->outs[co];
+			if (ss == NULL) {
+				ss = miss(v, d, css, co, cp+1, start);
+				if (ss == NULL)
+					break;	/* NOTE BREAK OUT */
+			}
+			cp++;
+			ss->lastseen = cp;
+			css = ss;
+			if ((ss->flags&POSTSTATE) && cp >= realmin)
+				break;		/* NOTE BREAK OUT */
+		}
+
+	if (ss == NULL)
+		return NULL;
+
+	if (coldp != NULL)	/* report last no-progress state set, if any */
+		*coldp = lastcold(v, d);
+
+	if ((ss->flags&POSTSTATE) && cp > min) {
+		assert(cp >= realmin);
+		cp--;
+	} else if (cp == v->stop && max == v->stop) {
+		co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1];
+		FDEBUG(("color %ld\n", (long)co));
+		ss = miss(v, d, css, co, cp, start);
+		/* match might have ended at eol */
+		if ((ss == NULL || !(ss->flags&POSTSTATE)) && hitstopp != NULL)
+			*hitstopp = 1;
+	}
+
+	if (ss == NULL || !(ss->flags&POSTSTATE))
+		return NULL;
+
+	return cp;
+}
+
+/*
+ - lastcold - determine last point at which no progress had been made
+ ^ static chr *lastcold(struct vars *, struct dfa *);
+ */
+static chr *			/* endpoint, or NULL */
+lastcold(v, d)
+struct vars *v;
+struct dfa *d;
+{
+	struct sset *ss;
+	chr *nopr;
+	int i;
+
+	nopr = d->lastnopr;
+	if (nopr == NULL)
+		nopr = v->start;
+	for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
+		if ((ss->flags&NOPROGRESS) && nopr < ss->lastseen)
+			nopr = ss->lastseen;
+	return nopr;
+}
+
+/*
+ - newdfa - set up a fresh DFA
+ ^ static struct dfa *newdfa(struct vars *, struct cnfa *,
+ ^ 	struct colormap *, struct smalldfa *);
+ */
+static struct dfa *
+newdfa(v, cnfa, cm, small)
+struct vars *v;
+struct cnfa *cnfa;
+struct colormap *cm;
+struct smalldfa *small;		/* preallocated space, may be NULL */
+{
+	struct dfa *d;
+	size_t nss = cnfa->nstates * 2;
+	int wordsper = (cnfa->nstates + UBITS - 1) / UBITS;
+	struct smalldfa *smallwas = small;
+
+	assert(cnfa != NULL && cnfa->nstates != 0);
+
+	if (nss <= FEWSTATES && cnfa->ncolors <= FEWCOLORS) {
+		assert(wordsper == 1);
+		if (small == NULL) {
+			small = (struct smalldfa *)MALLOC(
+						sizeof(struct smalldfa));
+			if (small == NULL) {
+				ERR(REG_ESPACE);
+				return NULL;
+			}
+		}
+		d = &small->dfa;
+		d->ssets = small->ssets;
+		d->statesarea = small->statesarea;
+		d->work = &d->statesarea[nss];
+		d->outsarea = small->outsarea;
+		d->incarea = small->incarea;
+		d->cptsmalloced = 0;
+		d->mallocarea = (smallwas == NULL) ? (char *)small : NULL;
+	} else {
+		d = (struct dfa *)MALLOC(sizeof(struct dfa));
+		if (d == NULL) {
+			ERR(REG_ESPACE);
+			return NULL;
+		}
+		d->ssets = (struct sset *)MALLOC(nss * sizeof(struct sset));
+		d->statesarea = (unsigned *)MALLOC((nss+WORK) * wordsper *
+							sizeof(unsigned));
+		d->work = &d->statesarea[nss * wordsper];
+		d->outsarea = (struct sset **)MALLOC(nss * cnfa->ncolors *
+							sizeof(struct sset *));
+		d->incarea = (struct arcp *)MALLOC(nss * cnfa->ncolors *
+							sizeof(struct arcp));
+		d->cptsmalloced = 1;
+		d->mallocarea = (char *)d;
+		if (d->ssets == NULL || d->statesarea == NULL ||
+				d->outsarea == NULL || d->incarea == NULL) {
+			freedfa(d);
+			ERR(REG_ESPACE);
+			return NULL;
+		}
+	}
+
+	d->nssets = (v->eflags&REG_SMALL) ? 7 : nss;
+	d->nssused = 0;
+	d->nstates = cnfa->nstates;
+	d->ncolors = cnfa->ncolors;
+	d->wordsper = wordsper;
+	d->cnfa = cnfa;
+	d->cm = cm;
+	d->lastpost = NULL;
+	d->lastnopr = NULL;
+	d->search = d->ssets;
+
+	/* initialization of sset fields is done as needed */
+
+	return d;
+}
+
+/*
+ - freedfa - free a DFA
+ ^ static VOID freedfa(struct dfa *);
+ */
+static VOID
+freedfa(d)
+struct dfa *d;
+{
+	if (d->cptsmalloced) {
+		if (d->ssets != NULL)
+			FREE(d->ssets);
+		if (d->statesarea != NULL)
+			FREE(d->statesarea);
+		if (d->outsarea != NULL)
+			FREE(d->outsarea);
+		if (d->incarea != NULL)
+			FREE(d->incarea);
+	}
+
+	if (d->mallocarea != NULL)
+		FREE(d->mallocarea);
+}
+
+/*
+ - hash - construct a hash code for a bitvector
+ * There are probably better ways, but they're more expensive.
+ ^ static unsigned hash(unsigned *, int);
+ */
+static unsigned
+hash(uv, n)
+unsigned *uv;
+int n;
+{
+	int i;
+	unsigned h;
+
+	h = 0;
+	for (i = 0; i < n; i++)
+		h ^= uv[i];
+	return h;
+}
+
+/*
+ - initialize - hand-craft a cache entry for startup, otherwise get ready
+ ^ static struct sset *initialize(struct vars *, struct dfa *, chr *);
+ */
+static struct sset *
+initialize(v, d, start)
+struct vars *v;			/* used only for debug flags */
+struct dfa *d;
+chr *start;
+{
+	struct sset *ss;
+	int i;
+
+	/* is previous one still there? */
+	if (d->nssused > 0 && (d->ssets[0].flags&STARTER))
+		ss = &d->ssets[0];
+	else {				/* no, must (re)build it */
+		ss = getvacant(v, d, start, start);
+		for (i = 0; i < d->wordsper; i++)
+			ss->states[i] = 0;
+		BSET(ss->states, d->cnfa->pre);
+		ss->hash = HASH(ss->states, d->wordsper);
+		assert(d->cnfa->pre != d->cnfa->post);
+		ss->flags = STARTER|LOCKED|NOPROGRESS;
+		/* lastseen dealt with below */
+	}
+
+	for (i = 0; i < d->nssused; i++)
+		d->ssets[i].lastseen = NULL;
+	ss->lastseen = start;		/* maybe untrue, but harmless */
+	d->lastpost = NULL;
+	d->lastnopr = NULL;
+	return ss;
+}
+
+/*
+ - miss - handle a cache miss
+ ^ static struct sset *miss(struct vars *, struct dfa *, struct sset *,
+ ^ 	pcolor, chr *, chr *);
+ */
+static struct sset *		/* NULL if goes to empty set */
+miss(v, d, css, co, cp, start)
+struct vars *v;			/* used only for debug flags */
+struct dfa *d;
+struct sset *css;
+pcolor co;
+chr *cp;			/* next chr */
+chr *start;			/* where the attempt got started */
+{
+	struct cnfa *cnfa = d->cnfa;
+	int i;
+	unsigned h;
+	struct carc *ca;
+	struct sset *p;
+	int ispost;
+	int noprogress;
+	int gotstate;
+	int dolacons;
+	int sawlacons;
+
+	/* for convenience, we can be called even if it might not be a miss */
+	if (css->outs[co] != NULL) {
+		FDEBUG(("hit\n"));
+		return css->outs[co];
+	}
+	FDEBUG(("miss\n"));
+
+	/* first, what set of states would we end up in? */
+	for (i = 0; i < d->wordsper; i++)
+		d->work[i] = 0;
+	ispost = 0;
+	noprogress = 1;
+	gotstate = 0;
+	for (i = 0; i < d->nstates; i++)
+		if (ISBSET(css->states, i))
+			for (ca = cnfa->states[i]+1; ca->co != COLORLESS; ca++)
+				if (ca->co == co) {
+					BSET(d->work, ca->to);
+					gotstate = 1;
+					if (ca->to == cnfa->post)
+						ispost = 1;
+					if (!cnfa->states[ca->to]->co)
+						noprogress = 0;
+					FDEBUG(("%d -> %d\n", i, ca->to));
+				}
+	dolacons = (gotstate) ? (cnfa->flags&HASLACONS) : 0;
+	sawlacons = 0;
+	while (dolacons) {		/* transitive closure */
+		dolacons = 0;
+		for (i = 0; i < d->nstates; i++)
+			if (ISBSET(d->work, i))
+				for (ca = cnfa->states[i]+1; ca->co != COLORLESS;
+									ca++) {
+					if (ca->co <= cnfa->ncolors)
+						continue; /* NOTE CONTINUE */
+					sawlacons = 1;
+					if (ISBSET(d->work, ca->to))
+						continue; /* NOTE CONTINUE */
+					if (!lacon(v, cnfa, cp, ca->co))
+						continue; /* NOTE CONTINUE */
+					BSET(d->work, ca->to);
+					dolacons = 1;
+					if (ca->to == cnfa->post)
+						ispost = 1;
+					if (!cnfa->states[ca->to]->co)
+						noprogress = 0;
+					FDEBUG(("%d :> %d\n", i, ca->to));
+				}
+	}
+	if (!gotstate)
+		return NULL;
+	h = HASH(d->work, d->wordsper);
+
+	/* next, is that in the cache? */
+	for (p = d->ssets, i = d->nssused; i > 0; p++, i--)
+		if (HIT(h, d->work, p, d->wordsper)) {
+			FDEBUG(("cached c%d\n", p - d->ssets));
+			break;			/* NOTE BREAK OUT */
+		}
+	if (i == 0) {		/* nope, need a new cache entry */
+		p = getvacant(v, d, cp, start);
+		assert(p != css);
+		for (i = 0; i < d->wordsper; i++)
+			p->states[i] = d->work[i];
+		p->hash = h;
+		p->flags = (ispost) ? POSTSTATE : 0;
+		if (noprogress)
+			p->flags |= NOPROGRESS;
+		/* lastseen to be dealt with by caller */
+	}
+
+	if (!sawlacons) {		/* lookahead conds. always cache miss */
+		FDEBUG(("c%d[%d]->c%d\n", css - d->ssets, co, p - d->ssets));
+		css->outs[co] = p;
+		css->inchain[co] = p->ins;
+		p->ins.ss = css;
+		p->ins.co = (color)co;
+	}
+	return p;
+}
+
+/*
+ - lacon - lookahead-constraint checker for miss()
+ ^ static int lacon(struct vars *, struct cnfa *, chr *, pcolor);
+ */
+static int			/* predicate:  constraint satisfied? */
+lacon(v, pcnfa, cp, co)
+struct vars *v;
+struct cnfa *pcnfa;		/* parent cnfa */
+chr *cp;
+pcolor co;			/* "color" of the lookahead constraint */
+{
+	int n;
+	struct subre *sub;
+	struct dfa *d;
+	struct smalldfa sd;
+	chr *end;
+
+	n = co - pcnfa->ncolors;
+	assert(n < v->g->nlacons && v->g->lacons != NULL);
+	FDEBUG(("=== testing lacon %d\n", n));
+	sub = &v->g->lacons[n];
+	d = newdfa(v, &sub->cnfa, &v->g->cmap, &sd);
+	if (d == NULL) {
+		ERR(REG_ESPACE);
+		return 0;
+	}
+	end = longest(v, d, cp, v->stop, (int *)NULL);
+	freedfa(d);
+	FDEBUG(("=== lacon %d match %d\n", n, (end != NULL)));
+	return (sub->subno) ? (end != NULL) : (end == NULL);
+}
+
+/*
+ - getvacant - get a vacant state set
+ * This routine clears out the inarcs and outarcs, but does not otherwise
+ * clear the innards of the state set -- that's up to the caller.
+ ^ static struct sset *getvacant(struct vars *, struct dfa *, chr *, chr *);
+ */
+static struct sset *
+getvacant(v, d, cp, start)
+struct vars *v;			/* used only for debug flags */
+struct dfa *d;
+chr *cp;
+chr *start;
+{
+	int i;
+	struct sset *ss;
+	struct sset *p;
+	struct arcp ap;
+	struct arcp lastap;
+	color co;
+
+	ss = pickss(v, d, cp, start);
+	assert(!(ss->flags&LOCKED));
+
+	/* clear out its inarcs, including self-referential ones */
+	ap = ss->ins;
+	while ((p = ap.ss) != NULL) {
+		co = ap.co;
+		FDEBUG(("zapping c%d's %ld outarc\n", p - d->ssets, (long)co));
+		p->outs[co] = NULL;
+		ap = p->inchain[co];
+		p->inchain[co].ss = NULL;	/* paranoia */
+	}
+	ss->ins.ss = NULL;
+
+	/* take it off the inarc chains of the ssets reached by its outarcs */
+	for (i = 0; i < d->ncolors; i++) {
+		p = ss->outs[i];
+		assert(p != ss);		/* not self-referential */
+		if (p == NULL)
+			continue;		/* NOTE CONTINUE */
+		FDEBUG(("del outarc %d from c%d's in chn\n", i, p - d->ssets));
+		if (p->ins.ss == ss && p->ins.co == i)
+			p->ins = ss->inchain[i];
+		else {
+			assert(p->ins.ss != NULL);
+			for (ap = p->ins; ap.ss != NULL &&
+						!(ap.ss == ss && ap.co == i);
+						ap = ap.ss->inchain[ap.co])
+				lastap = ap;
+			assert(ap.ss != NULL);
+			lastap.ss->inchain[lastap.co] = ss->inchain[i];
+		}
+		ss->outs[i] = NULL;
+		ss->inchain[i].ss = NULL;
+	}
+
+	/* if ss was a success state, may need to remember location */
+	if ((ss->flags&POSTSTATE) && ss->lastseen != d->lastpost &&
+			(d->lastpost == NULL || d->lastpost < ss->lastseen))
+		d->lastpost = ss->lastseen;
+
+	/* likewise for a no-progress state */
+	if ((ss->flags&NOPROGRESS) && ss->lastseen != d->lastnopr &&
+			(d->lastnopr == NULL || d->lastnopr < ss->lastseen))
+		d->lastnopr = ss->lastseen;
+
+	return ss;
+}
+
+/*
+ - pickss - pick the next stateset to be used
+ ^ static struct sset *pickss(struct vars *, struct dfa *, chr *, chr *);
+ */
+static struct sset *
+pickss(v, d, cp, start)
+struct vars *v;			/* used only for debug flags */
+struct dfa *d;
+chr *cp;
+chr *start;
+{
+	int i;
+	struct sset *ss;
+	struct sset *end;
+	chr *ancient;
+
+	/* shortcut for cases where cache isn't full */
+	if (d->nssused < d->nssets) {
+		i = d->nssused;
+		d->nssused++;
+		ss = &d->ssets[i];
+		FDEBUG(("new c%d\n", i));
+		/* set up innards */
+		ss->states = &d->statesarea[i * d->wordsper];
+		ss->flags = 0;
+		ss->ins.ss = NULL;
+		ss->ins.co = WHITE;		/* give it some value */
+		ss->outs = &d->outsarea[i * d->ncolors];
+		ss->inchain = &d->incarea[i * d->ncolors];
+		for (i = 0; i < d->ncolors; i++) {
+			ss->outs[i] = NULL;
+			ss->inchain[i].ss = NULL;
+		}
+		return ss;
+	}
+
+	/* look for oldest, or old enough anyway */
+	if (cp - start > d->nssets*2/3)		/* oldest 33% are expendable */
+		ancient = cp - d->nssets*2/3;
+	else
+		ancient = start;
+	for (ss = d->search, end = &d->ssets[d->nssets]; ss < end; ss++)
+		if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
+							!(ss->flags&LOCKED)) {
+			d->search = ss + 1;
+			FDEBUG(("replacing c%d\n", ss - d->ssets));
+			return ss;
+		}
+	for (ss = d->ssets, end = d->search; ss < end; ss++)
+		if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
+							!(ss->flags&LOCKED)) {
+			d->search = ss + 1;
+			FDEBUG(("replacing c%d\n", ss - d->ssets));
+			return ss;
+		}
+
+	/* nobody's old enough?!? -- something's really wrong */
+	FDEBUG(("can't find victim to replace!\n"));
+	assert(NOTREACHED);
+	ERR(REG_ASSERT);
+	return d->ssets;
+}

src/regex/regerror.c

@@ -0,0 +1,109 @@
+/*
+ * regerror - error-code expansion
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "regguts.h"
+
+/* unknown-error explanation */
+static char unk[] = "*** unknown regex error code 0x%x ***";
+
+/* struct to map among codes, code names, and explanations */
+static struct rerr {
+	int code;
+	char *name;
+	char *explain;
+} rerrs[] = {
+	/* the actual table is built from regex.h */
+#	include "regerrs.h"
+	{ -1,	"",	"oops" },	/* explanation special-cased in code */
+};
+
+/*
+ - regerror - the interface to error numbers
+ */
+/* ARGSUSED */
+size_t				/* actual space needed (including NUL) */
+regerror(errcode, preg, errbuf, errbuf_size)
+int errcode;			/* error code, or REG_ATOI or REG_ITOA */
+CONST regex_t *preg;		/* associated regex_t (unused at present) */
+char *errbuf;			/* result buffer (unless errbuf_size==0) */
+size_t errbuf_size;		/* available space in errbuf, can be 0 */
+{
+	struct rerr *r;
+	char *msg;
+	char convbuf[sizeof(unk)+50];	/* 50 = plenty for int */
+	size_t len;
+	int icode;
+
+	switch (errcode) {
+	case REG_ATOI:		/* convert name to number */
+		for (r = rerrs; r->code >= 0; r++)
+			if (strcmp(r->name, errbuf) == 0)
+				break;
+		sprintf(convbuf, "%d", r->code);	/* -1 for unknown */
+		msg = convbuf;
+		break;
+	case REG_ITOA:		/* convert number to name */
+		icode = atoi(errbuf);	/* not our problem if this fails */
+		for (r = rerrs; r->code >= 0; r++)
+			if (r->code == icode)
+				break;
+		if (r->code >= 0)
+			msg = r->name;
+		else {			/* unknown; tell him the number */
+			sprintf(convbuf, "REG_%u", (unsigned)icode);
+			msg = convbuf;
+		}
+		break;
+	default:		/* a real, normal error code */
+		for (r = rerrs; r->code >= 0; r++)
+			if (r->code == errcode)
+				break;
+		if (r->code >= 0)
+			msg = r->explain;
+		else {			/* unknown; say so */
+			sprintf(convbuf, unk, errcode);
+			msg = convbuf;
+		}
+		break;
+	}
+
+	len = strlen(msg) + 1;		/* space needed, including NUL */
+	if (errbuf_size > 0) {
+		if (errbuf_size > len)
+			strcpy(errbuf, msg);
+		else {			/* truncate to fit */
+			strncpy(errbuf, msg, errbuf_size-1);
+			errbuf[errbuf_size-1] = '\0';
+		}
+	}
+
+	return len;
+}

src/regex/regerrs.h

@@ -0,0 +1,18 @@
+{ REG_OKAY,	"REG_OKAY",	"no errors detected" },
+{ REG_NOMATCH,	"REG_NOMATCH",	"failed to match" },
+{ REG_BADPAT,	"REG_BADPAT",	"invalid regexp (reg version 0.8)" },
+{ REG_ECOLLATE,	"REG_ECOLLATE",	"invalid collating element" },
+{ REG_ECTYPE,	"REG_ECTYPE",	"invalid character class" },
+{ REG_EESCAPE,	"REG_EESCAPE",	"invalid escape \\ sequence" },
+{ REG_ESUBREG,	"REG_ESUBREG",	"invalid backreference number" },
+{ REG_EBRACK,	"REG_EBRACK",	"brackets [] not balanced" },
+{ REG_EPAREN,	"REG_EPAREN",	"parentheses () not balanced" },
+{ REG_EBRACE,	"REG_EBRACE",	"braces {} not balanced" },
+{ REG_BADBR,	"REG_BADBR",	"invalid repetition count(s)" },
+{ REG_ERANGE,	"REG_ERANGE",	"invalid character range" },
+{ REG_ESPACE,	"REG_ESPACE",	"out of memory" },
+{ REG_BADRPT,	"REG_BADRPT",	"quantifier operand invalid" },
+{ REG_ASSERT,	"REG_ASSERT",	"\"can't happen\" -- you found a bug" },
+{ REG_INVARG,	"REG_INVARG",	"invalid argument to regex function" },
+{ REG_MIXED,	"REG_MIXED",	"character widths of regex and string differ" },
+{ REG_BADOPT,	"REG_BADOPT",	"invalid embedded option" },

src/regex/regex.h

@@ -0,0 +1,341 @@
+#ifndef _REGEX_H_
+#define	_REGEX_H_	/* never again */
+/*
+ * regular expressions
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ *
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ *
+ * Prototypes etc. marked with "^" within comments get gathered up (and
+ * possibly edited) by the regfwd program and inserted near the bottom of
+ * this file.
+ *
+ * We offer the option of declaring one wide-character version of the
+ * RE functions as well as the char versions.  To do that, define
+ * __REG_WIDE_T to the type of wide characters (unfortunately, there
+ * is no consensus that wchar_t is suitable) and __REG_WIDE_COMPILE and
+ * __REG_WIDE_EXEC to the names to be used for the compile and execute
+ * functions (suggestion:  re_Xcomp and re_Xexec, where X is a letter
+ * suggestive of the wide type, e.g. re_ucomp and re_uexec for Unicode).
+ * For cranky old compilers, it may be necessary to do something like:
+ * #define	__REG_WIDE_COMPILE(a,b,c,d)	re_Xcomp(a,b,c,d)
+ * #define	__REG_WIDE_EXEC(a,b,c,d,e,f,g)	re_Xexec(a,b,c,d,e,f,g)
+ * rather than just #defining the names as parameterless macros.
+ *
+ * For some specialized purposes, it may be desirable to suppress the
+ * declarations of the "front end" functions, regcomp() and regexec(),
+ * or of the char versions of the compile and execute functions.  To
+ * suppress the front-end functions, define __REG_NOFRONT.  To suppress
+ * the char versions, define __REG_NOCHAR.
+ *
+ * The right place to do those defines (and some others you may want, see
+ * below) would be <sys/types.h>.  If you don't have control of that file,
+ * the right place to add your own defines to this file is marked below.
+ * This is normally done automatically, by the makefile and regmkhdr, based
+ * on the contents of regcustom.h.
+ */
+
+
+
+/*
+ * voodoo for C++
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+/*
+ * Add your own defines, if needed, here.
+ */
+
+
+
+/*
+ * Location where a chunk of regcustom.h is automatically spliced into
+ * this file (working from its prototype, regproto.h).
+ */
+/* --- begin --- */
+/* ensure certain things don't sneak in from system headers */
+#ifdef __REG_WIDE_T
+#undef __REG_WIDE_T
+#endif
+#ifdef __REG_WIDE_COMPILE
+#undef __REG_WIDE_COMPILE
+#endif
+#ifdef __REG_WIDE_EXEC
+#undef __REG_WIDE_EXEC
+#endif
+#ifdef __REG_REGOFF_T
+#undef __REG_REGOFF_T
+#endif
+#ifdef __REG_VOID_T
+#undef __REG_VOID_T
+#endif
+#ifdef __REG_CONST
+#undef __REG_CONST
+#endif
+#ifdef __REG_NOFRONT
+#undef __REG_NOFRONT
+#endif
+#ifdef __REG_NOCHAR
+#undef __REG_NOCHAR
+#endif
+/* interface types */
+#define	__REG_WIDE_T	Tcl_UniChar
+#define	__REG_REGOFF_T	long	/* not really right, but good enough... */
+#define	__REG_VOID_T	VOID
+#define	__REG_CONST	CONST
+/* names and declarations */
+#define	__REG_WIDE_COMPILE	TclReComp
+#define	__REG_WIDE_EXEC		TclReExec
+#define	__REG_NOFRONT		/* don't want regcomp() and regexec() */
+#define	__REG_NOCHAR		/* or the char versions */
+#define	regfree		TclReFree
+#define	regerror	TclReError
+/* --- end --- */
+
+
+/*
+ * interface types etc.
+ */
+
+/*
+ * regoff_t has to be large enough to hold either off_t or ssize_t,
+ * and must be signed; it's only a guess that long is suitable, so we
+ * offer <sys/types.h> an override.
+ */
+#ifdef __REG_REGOFF_T
+typedef __REG_REGOFF_T regoff_t;
+#else
+typedef long regoff_t;
+#endif
+
+/*
+ * For benefit of old compilers, we offer <sys/types.h> the option of
+ * overriding the `void' type used to declare nonexistent return types.
+ */
+#ifdef __REG_VOID_T
+typedef __REG_VOID_T re_void;
+#else
+typedef void re_void;
+#endif
+
+/*
+ * Also for benefit of old compilers, <sys/types.h> can supply a macro
+ * which expands to a substitute for `const'.
+ */
+#ifndef __REG_CONST
+#define	__REG_CONST	const
+#endif
+
+
+
+/*
+ * other interface types
+ */
+
+/* the biggie, a compiled RE (or rather, a front end to same) */
+typedef struct {
+	int re_magic;		/* magic number */
+	size_t re_nsub;		/* number of subexpressions */
+	long re_info;		/* information about RE */
+#		define	REG_UBACKREF		000001
+#		define	REG_ULOOKAHEAD		000002
+#		define	REG_UBOUNDS		000004
+#		define	REG_UBRACES		000010
+#		define	REG_UBSALNUM		000020
+#		define	REG_UPBOTCH		000040
+#		define	REG_UBBS		000100
+#		define	REG_UNONPOSIX		000200
+#		define	REG_UUNSPEC		000400
+#		define	REG_UUNPORT		001000
+#		define	REG_ULOCALE		002000
+#		define	REG_UEMPTYMATCH		004000
+#		define	REG_UIMPOSSIBLE		010000
+#		define	REG_USHORTEST		020000
+	int re_csize;		/* sizeof(character) */
+	char *re_endp;		/* backward compatibility kludge */
+	/* the rest is opaque pointers to hidden innards */
+	char *re_guts;		/* `char *' is more portable than `void *' */
+	char *re_fns;
+} regex_t;
+
+/* result reporting (may acquire more fields later) */
+typedef struct {
+	regoff_t rm_so;		/* start of substring */
+	regoff_t rm_eo;		/* end of substring */
+} regmatch_t;
+
+/* supplementary control and reporting */
+typedef struct {
+	regmatch_t rm_extend;	/* see REG_EXPECT */
+} rm_detail_t;
+
+
+
+/*
+ * compilation
+ ^ #ifndef __REG_NOCHAR
+ ^ int re_comp(regex_t *, __REG_CONST char *, size_t, int);
+ ^ #endif
+ ^ #ifndef __REG_NOFRONT
+ ^ int regcomp(regex_t *, __REG_CONST char *, int);
+ ^ #endif
+ ^ #ifdef __REG_WIDE_T
+ ^ int __REG_WIDE_COMPILE(regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int);
+ ^ #endif
+ */
+#define	REG_BASIC	000000	/* BREs (convenience) */
+#define	REG_EXTENDED	000001	/* EREs */
+#define	REG_ADVF	000002	/* advanced features in EREs */
+#define	REG_ADVANCED	000003	/* AREs (which are also EREs) */
+#define	REG_QUOTE	000004	/* no special characters, none */
+#define	REG_NOSPEC	REG_QUOTE	/* historical synonym */
+#define	REG_ICASE	000010	/* ignore case */
+#define	REG_NOSUB	000020	/* don't care about subexpressions */
+#define	REG_EXPANDED	000040	/* expanded format, white space & comments */
+#define	REG_NLSTOP	000100	/* \n doesn't match . or [^ ] */
+#define	REG_NLANCH	000200	/* ^ matches after \n, $ before */
+#define	REG_NEWLINE	000300	/* newlines are line terminators */
+#define	REG_PEND	000400	/* ugh -- backward-compatibility hack */
+#define	REG_EXPECT	001000	/* report details on partial/limited matches */
+#define	REG_BOSONLY	002000	/* temporary kludge for BOS-only matches */
+#define	REG_DUMP	004000	/* none of your business :-) */
+#define	REG_FAKE	010000	/* none of your business :-) */
+#define	REG_PROGRESS	020000	/* none of your business :-) */
+
+
+
+/*
+ * execution
+ ^ #ifndef __REG_NOCHAR
+ ^ int re_exec(regex_t *, __REG_CONST char *, size_t,
+ ^				rm_detail_t *, size_t, regmatch_t [], int);
+ ^ #endif
+ ^ #ifndef __REG_NOFRONT
+ ^ int regexec(regex_t *, __REG_CONST char *, size_t, regmatch_t [], int);
+ ^ #endif
+ ^ #ifdef __REG_WIDE_T
+ ^ int __REG_WIDE_EXEC(regex_t *, __REG_CONST __REG_WIDE_T *, size_t,
+ ^				rm_detail_t *, size_t, regmatch_t [], int);
+ ^ #endif
+ */
+#define	REG_NOTBOL	0001	/* BOS is not BOL */
+#define	REG_NOTEOL	0002	/* EOS is not EOL */
+#define	REG_STARTEND	0004	/* backward compatibility kludge */
+#define	REG_FTRACE	0010	/* none of your business */
+#define	REG_MTRACE	0020	/* none of your business */
+#define	REG_SMALL	0040	/* none of your business */
+
+
+
+/*
+ * misc generics (may be more functions here eventually)
+ ^ re_void regfree(regex_t *);
+ */
+
+
+
+/*
+ * error reporting
+ * Be careful if modifying the list of error codes -- the table used by
+ * regerror() is generated automatically from this file!
+ *
+ * Note that there is no wide-char variant of regerror at this time; what
+ * kind of character is used for error reports is independent of what kind
+ * is used in matching.
+ *
+ ^ extern size_t regerror(int, __REG_CONST regex_t *, char *, size_t);
+ */
+#define	REG_OKAY	 0	/* no errors detected */
+#define	REG_NOMATCH	 1	/* failed to match */
+#define	REG_BADPAT	 2	/* invalid regexp */
+#define	REG_ECOLLATE	 3	/* invalid collating element */
+#define	REG_ECTYPE	 4	/* invalid character class */
+#define	REG_EESCAPE	 5	/* invalid escape \ sequence */
+#define	REG_ESUBREG	 6	/* invalid backreference number */
+#define	REG_EBRACK	 7	/* brackets [] not balanced */
+#define	REG_EPAREN	 8	/* parentheses () not balanced */
+#define	REG_EBRACE	 9	/* braces {} not balanced */
+#define	REG_BADBR	10	/* invalid repetition count(s) */
+#define	REG_ERANGE	11	/* invalid character range */
+#define	REG_ESPACE	12	/* out of memory */
+#define	REG_BADRPT	13	/* quantifier operand invalid */
+#define	REG_ASSERT	15	/* "can't happen" -- you found a bug */
+#define	REG_INVARG	16	/* invalid argument to regex function */
+#define	REG_MIXED	17	/* character widths of regex and string differ */
+#define	REG_BADOPT	18	/* invalid embedded option */
+/* two specials for debugging and testing */
+#define	REG_ATOI	101	/* convert error-code name to number */
+#define	REG_ITOA	102	/* convert error-code number to name */
+
+
+
+/*
+ * the prototypes, as possibly munched by regfwd
+ */
+/* =====^!^===== begin forwards =====^!^===== */
+/* automatically gathered by fwd; do not hand-edit */
+/* === regproto.h === */
+#ifndef __REG_NOCHAR
+int re_comp _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, int));
+#endif
+#ifndef __REG_NOFRONT
+int regcomp _ANSI_ARGS_((regex_t *, __REG_CONST char *, int));
+#endif
+#ifdef __REG_WIDE_T
+int __REG_WIDE_COMPILE _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int));
+#endif
+#ifndef __REG_NOCHAR
+int re_exec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
+#endif
+#ifndef __REG_NOFRONT
+int regexec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, regmatch_t [], int));
+#endif
+#ifdef __REG_WIDE_T
+int __REG_WIDE_EXEC _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
+#endif
+re_void regfree _ANSI_ARGS_((regex_t *));
+extern size_t regerror _ANSI_ARGS_((int, __REG_CONST regex_t *, char *, size_t));
+/* automatically gathered by fwd; do not hand-edit */
+/* =====^!^===== end forwards =====^!^===== */
+
+
+
+/*
+ * more C++ voodoo
+ */
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif

src/regex/regfree.c

@@ -0,0 +1,53 @@
+/*
+ * regfree - free an RE
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ *
+ * You might think that this could be incorporated into regcomp.c, and
+ * that would be a reasonable idea... except that this is a generic
+ * function (with a generic name), applicable to all compiled REs
+ * regardless of the size of their characters, whereas the stuff in
+ * regcomp.c gets compiled once per character size.
+ */
+
+#include "regguts.h"
+
+/*
+ - regfree - free an RE (generic function, punts to RE-specific function)
+ *
+ * Ignoring invocation with NULL is a convenience.
+ */
+VOID
+regfree(re)
+regex_t *re;
+{
+	if (re == NULL)
+		return;
+	(*((struct fns *)re->re_fns)->free)(re);
+}

src/regex/regfronts.c

@@ -0,0 +1,83 @@
+/*
+ * regcomp and regexec - front ends to re_ routines
+ *
+ * Mostly for implementation of backward-compatibility kludges.  Note
+ * that these routines exist ONLY in char versions.
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "regguts.h"
+
+/*
+ - regcomp - compile regular expression
+ */
+int
+regcomp(re, str, flags)
+regex_t *re;
+CONST char *str;
+int flags;
+{
+	size_t len;
+	int f = flags;
+
+	if (f&REG_PEND) {
+		len = re->re_endp - str;
+		f &= ~REG_PEND;
+	} else
+		len = strlen(str);
+
+	return re_comp(re, str, len, f);
+}
+
+/*
+ - regexec - execute regular expression
+ */
+int
+regexec(re, str, nmatch, pmatch, flags)
+regex_t *re;
+CONST char *str;
+size_t nmatch;
+regmatch_t pmatch[];
+int flags;
+{
+	CONST char *start;
+	size_t len;
+	int f = flags;
+
+	if (f&REG_STARTEND) {
+		start = str + pmatch[0].rm_so;
+		len = pmatch[0].rm_eo - pmatch[0].rm_so;
+		f &= ~REG_STARTEND;
+	} else {
+		start = str;
+		len = strlen(str);
+	}
+
+	return re_exec(re, start, len, nmatch, pmatch, f);
+}

src/regex/regguts.h

@@ -0,0 +1,418 @@
+/*
+ * Internal interface definitions, etc., for the reg package
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ * 
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them. 
+ * 
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ * 
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+/*
+ * Environmental customization.  It should not (I hope) be necessary to
+ * alter the file you are now reading -- regcustom.h should handle it all,
+ * given care here and elsewhere.
+ */
+#include "regcustom.h"
+
+
+
+/*
+ * Things that regcustom.h might override.
+ */
+
+/* standard header files (NULL is a reasonable indicator for them) */
+#ifndef NULL
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <limits.h>
+#include <string.h>
+#endif
+
+/* assertions */
+#ifndef assert
+#	ifndef REG_DEBUG
+#	define	NDEBUG		/* no assertions */
+#	endif
+#include <assert.h>
+#endif
+
+/* voids */
+#ifndef VOID
+#define	VOID	void			/* for function return values */
+#endif
+#ifndef DISCARD
+#define	DISCARD	VOID			/* for throwing values away */
+#endif
+#ifndef PVOID
+#define	PVOID	VOID *			/* generic pointer */
+#endif
+#ifndef VS
+#define	VS(x)	((PVOID)(x))		/* cast something to generic ptr */
+#endif
+#ifndef NOPARMS
+#define	NOPARMS	VOID			/* for empty parm lists */
+#endif
+
+/* const */
+#ifndef CONST
+#define	CONST	const			/* for old compilers, might be empty */
+#endif
+
+/* function-pointer declarator */
+#ifndef FUNCPTR
+#if __STDC__ >= 1
+#define	FUNCPTR(name, args)	(*name)args
+#else
+#define	FUNCPTR(name, args)	(*name)()
+#endif
+#endif
+
+/* memory allocation */
+#ifndef MALLOC
+#define	MALLOC(n)	malloc(n)
+#endif
+#ifndef REALLOC
+#define	REALLOC(p, n)	realloc(VS(p), n)
+#endif
+#ifndef FREE
+#define	FREE(p)		free(VS(p))
+#endif
+
+/* want size of a char in bits, and max value in bounded quantifiers */
+#ifndef CHAR_BIT
+#include <limits.h>
+#endif
+#ifndef _POSIX2_RE_DUP_MAX
+#define	_POSIX2_RE_DUP_MAX	255	/* normally from <limits.h> */
+#endif
+
+
+
+/*
+ * misc
+ */
+
+#define	NOTREACHED	0
+#define	xxx		1
+
+#define	DUPMAX	_POSIX2_RE_DUP_MAX
+#define	INFINITY	(DUPMAX+1)
+
+#define	REMAGIC	0xfed7		/* magic number for main struct */
+
+
+
+/*
+ * debugging facilities
+ */
+#ifdef REG_DEBUG
+/* FDEBUG does finite-state tracing */
+#define	FDEBUG(arglist)	{ if (v->eflags&REG_FTRACE) printf arglist; }
+/* MDEBUG does higher-level tracing */
+#define	MDEBUG(arglist)	{ if (v->eflags&REG_MTRACE) printf arglist; }
+#else
+#define	FDEBUG(arglist)	{}
+#define	MDEBUG(arglist)	{}
+#endif
+
+
+
+/*
+ * bitmap manipulation
+ */
+#define	UBITS	(CHAR_BIT * sizeof(unsigned))
+#define	BSET(uv, sn)	((uv)[(sn)/UBITS] |= (unsigned)1 << ((sn)%UBITS))
+#define	ISBSET(uv, sn)	((uv)[(sn)/UBITS] & ((unsigned)1 << ((sn)%UBITS)))
+
+
+
+/*
+ * We dissect a chr into byts for colormap table indexing.  Here we define
+ * a byt, which will be the same as a byte on most machines...  The exact
+ * size of a byt is not critical, but about 8 bits is good, and extraction
+ * of 8-bit chunks is sometimes especially fast.
+ */
+#ifndef BYTBITS
+#define	BYTBITS	8		/* bits in a byt */
+#endif
+#define	BYTTAB	(1<<BYTBITS)	/* size of table with one entry per byt value */
+#define	BYTMASK	(BYTTAB-1)	/* bit mask for byt */
+#define	NBYTS	((CHRBITS+BYTBITS-1)/BYTBITS)
+/* the definition of GETCOLOR(), below, assumes NBYTS <= 4 */
+
+
+
+/*
+ * As soon as possible, we map chrs into equivalence classes -- "colors" --
+ * which are of much more manageable number.
+ */
+typedef short color;		/* colors of characters */
+typedef int pcolor;		/* what color promotes to */
+#define	COLORLESS	(-1)	/* impossible color */
+#define	WHITE		0	/* default color, parent of all others */
+
+
+
+/*
+ * A colormap is a tree -- more precisely, a DAG -- indexed at each level
+ * by a byt of the chr, to map the chr to a color efficiently.  Because
+ * lower sections of the tree can be shared, it can exploit the usual
+ * sparseness of such a mapping table.  The tree is always NBYTS levels
+ * deep (in the past it was shallower during construction but was "filled"
+ * to full depth at the end of that); areas that are unaltered as yet point
+ * to "fill blocks" which are entirely WHITE in color.
+ */
+
+/* the tree itself */
+struct colors {
+	color ccolor[BYTTAB];
+};
+struct ptrs {
+	union tree *pptr[BYTTAB];
+};
+union tree {
+	struct colors colors;
+	struct ptrs ptrs;
+};
+#define	tcolor	colors.ccolor
+#define	tptr	ptrs.pptr
+
+/* internal per-color structure for the color machinery */
+struct colordesc {
+	uchr nchrs;		/* number of chars of this color */
+	color sub;		/* open subcolor (if any); free chain ptr */
+#		define	NOSUB	COLORLESS
+	struct arc *arcs;	/* color chain */
+	int flags;
+#		define	FREECOL	01	/* currently free */
+#		define	PSEUDO	02	/* pseudocolor, no real chars */
+#	define	UNUSEDCOLOR(cd)	((cd)->flags&FREECOL)
+	union tree *block;	/* block of solid color, if any */
+};
+
+/* the color map itself */
+struct colormap {
+	int magic;
+#		define	CMMAGIC	0x876
+	struct vars *v;			/* for compile error reporting */
+	size_t ncds;			/* number of colordescs */
+	size_t max;			/* highest in use */
+	color free;			/* beginning of free chain (if non-0) */
+	struct colordesc *cd;
+#	define	CDEND(cm)	(&(cm)->cd[(cm)->max + 1])
+#		define	NINLINECDS	((size_t)10)
+	struct colordesc cdspace[NINLINECDS];
+	union tree tree[NBYTS];		/* tree top, plus fill blocks */
+};
+
+/* optimization magic to do fast chr->color mapping */
+#define	B0(c)	((c) & BYTMASK)
+#define	B1(c)	(((c)>>BYTBITS) & BYTMASK)
+#define	B2(c)	(((c)>>(2*BYTBITS)) & BYTMASK)
+#define	B3(c)	(((c)>>(3*BYTBITS)) & BYTMASK)
+#if NBYTS == 1
+#define	GETCOLOR(cm, c)	((cm)->tree->tcolor[B0(c)])
+#endif
+/* beware, for NBYTS>1, GETCOLOR() is unsafe -- 2nd arg used repeatedly */
+#if NBYTS == 2
+#define	GETCOLOR(cm, c)	((cm)->tree->tptr[B1(c)]->tcolor[B0(c)])
+#endif
+#if NBYTS == 4
+#define	GETCOLOR(cm, c)	((cm)->tree->tptr[B3(c)]->tptr[B2(c)]->tptr[B1(c)]->tcolor[B0(c)])
+#endif
+
+
+
+/*
+ * Interface definitions for locale-interface functions in locale.c.
+ * Multi-character collating elements (MCCEs) cause most of the trouble.
+ */
+struct cvec {
+	int nchrs;		/* number of chrs */
+	int chrspace;		/* number of chrs possible */
+	chr *chrs;		/* pointer to vector of chrs */
+	int nranges;		/* number of ranges (chr pairs) */
+	int rangespace;		/* number of chrs possible */
+	chr *ranges;		/* pointer to vector of chr pairs */
+	int nmcces;		/* number of MCCEs */
+	int mccespace;		/* number of MCCEs possible */
+	int nmccechrs;		/* number of chrs used for MCCEs */
+	chr *mcces[1];		/* pointers to 0-terminated MCCEs */
+				/* and both batches of chrs are on the end */
+};
+
+/* caution:  this value cannot be changed easily */
+#define	MAXMCCE	2		/* length of longest MCCE */
+
+
+
+/*
+ * definitions for NFA internal representation
+ *
+ * Having a "from" pointer within each arc may seem redundant, but it
+ * saves a lot of hassle.
+ */
+struct state;
+
+struct arc {
+	int type;
+#		define	ARCFREE	'\0'
+	color co;
+	struct state *from;	/* where it's from (and contained within) */
+	struct state *to;	/* where it's to */
+	struct arc *outchain;	/* *from's outs chain or free chain */
+#	define	freechain	outchain
+	struct arc *inchain;	/* *to's ins chain */
+	struct arc *colorchain;	/* color's arc chain */
+};
+
+struct arcbatch {		/* for bulk allocation of arcs */
+	struct arcbatch *next;
+#	define	ABSIZE	10
+	struct arc a[ABSIZE];
+};
+
+struct state {
+	int no;
+#		define	FREESTATE	(-1)
+	char flag;		/* marks special states */
+	int nins;		/* number of inarcs */
+	struct arc *ins;	/* chain of inarcs */
+	int nouts;		/* number of outarcs */
+	struct arc *outs;	/* chain of outarcs */
+	struct arc *free;	/* chain of free arcs */
+	struct state *tmp;	/* temporary for traversal algorithms */
+	struct state *next;	/* chain for traversing all */
+	struct state *prev;	/* back chain */
+	struct arcbatch oas;	/* first arcbatch, avoid malloc in easy case */
+	int noas;		/* number of arcs used in first arcbatch */
+};
+
+struct nfa {
+	struct state *pre;	/* pre-initial state */
+	struct state *init;	/* initial state */
+	struct state *final;	/* final state */
+	struct state *post;	/* post-final state */
+	int nstates;		/* for numbering states */
+	struct state *states;	/* state-chain header */
+	struct state *slast;	/* tail of the chain */
+	struct state *free;	/* free list */
+	struct colormap *cm;	/* the color map */
+	color bos[2];		/* colors, if any, assigned to BOS and BOL */
+	color eos[2];		/* colors, if any, assigned to EOS and EOL */
+	struct vars *v;		/* simplifies compile error reporting */
+	struct nfa *parent;	/* parent NFA, if any */
+};
+
+
+
+/*
+ * definitions for compacted NFA
+ */
+struct carc {
+	color co;		/* COLORLESS is list terminator */
+	int to;			/* state number */
+};
+
+struct cnfa {
+	int nstates;		/* number of states */
+	int ncolors;		/* number of colors */
+	int flags;
+#		define	HASLACONS	01	/* uses lookahead constraints */
+	int pre;		/* setup state number */
+	int post;		/* teardown state number */
+	color bos[2];		/* colors, if any, assigned to BOS and BOL */
+	color eos[2];		/* colors, if any, assigned to EOS and EOL */
+	struct carc **states;	/* vector of pointers to outarc lists */
+	struct carc *arcs;	/* the area for the lists */
+};
+#define	ZAPCNFA(cnfa)	((cnfa).nstates = 0)
+#define	NULLCNFA(cnfa)	((cnfa).nstates == 0)
+
+
+
+/*
+ * subexpression tree
+ */
+struct subre {
+	char op;		/* '|', '.' (concat), 'b' (backref), '(', '=' */
+	char flags;
+#		define	LONGER	01	/* prefers longer match */
+#		define	SHORTER	02	/* prefers shorter match */
+#		define	MIXED	04	/* mixed preference below */
+#		define	CAP	010	/* capturing parens below */
+#		define	BACKR	020	/* back reference below */
+#		define	INUSE	0100	/* in use in final tree */
+#		define	LOCAL	03	/* bits which may not propagate up */
+#		define	LMIX(f)	((f)<<2)	/* LONGER -> MIXED */
+#		define	SMIX(f)	((f)<<1)	/* SHORTER -> MIXED */
+#		define	UP(f)	(((f)&~LOCAL) | (LMIX(f) & SMIX(f) & MIXED))
+#		define	MESSY(f)	((f)&(MIXED|CAP|BACKR))
+#		define	PREF(f)	((f)&LOCAL)
+#		define	PREF2(f1, f2)	((PREF(f1) != 0) ? PREF(f1) : PREF(f2))
+#		define	COMBINE(f1, f2)	(UP((f1)|(f2)) | PREF2(f1, f2))
+	short retry;		/* index into retry memory */
+	int subno;		/* subexpression number (for 'b' and '(') */
+	short min;		/* min repetitions, for backref only */
+	short max;		/* max repetitions, for backref only */
+	struct subre *left;	/* left child, if any (also freelist chain) */
+	struct subre *right;	/* right child, if any */
+	struct state *begin;	/* outarcs from here... */
+	struct state *end;	/* ...ending in inarcs here */
+	struct cnfa cnfa;	/* compacted NFA, if any */
+	struct subre *chain;	/* for bookkeeping and error cleanup */
+};
+
+
+
+/*
+ * table of function pointers for generic manipulation functions
+ * A regex_t's re_fns points to one of these.
+ */
+struct fns {
+	VOID FUNCPTR(free, (regex_t *));
+};
+
+
+
+/*
+ * the insides of a regex_t, hidden behind a void *
+ */
+struct guts {
+	int magic;
+#		define	GUTSMAGIC	0xfed9
+	int cflags;		/* copy of compile flags */
+	long info;		/* copy of re_info */
+	size_t nsub;		/* copy of re_nsub */
+	struct subre *tree;
+	struct cnfa search;	/* for fast preliminary search */
+	int ntree;
+	struct colormap cmap;
+	int FUNCPTR(compare, (CONST chr *, CONST chr *, size_t));
+	struct subre *lacons;	/* lookahead-constraint vector */
+	int nlacons;		/* size of lacons */
+};

src/regex/tclUniData.c

@@ -0,0 +1,904 @@
+/*
+ * tclUniData.c --
+ *
+ *	Declarations of Unicode character information tables.  This file is
+ *	automatically generated by the tools/uniParse.tcl script.  Do not
+ *	modify this file by hand.
+ *
+ * Copyright (c) 1998 by Scriptics Corporation.
+ * All rights reserved.
+ *
+ * RCS: @(#) $Id$
+ */
+
+/*
+ * A 16-bit Unicode character is split into two parts in order to index
+ * into the following tables.  The lower OFFSET_BITS comprise an offset
+ * into a page of characters.  The upper bits comprise the page number.
+ */
+
+#define OFFSET_BITS 5
+
+/*
+ * The pageMap is indexed by page number and returns an alternate page number
+ * that identifies a unique page of characters.  Many Unicode characters map
+ * to the same alternate page number.
+ */
+
+static unsigned char pageMap[] = {
+    0, 1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 7, 15, 16, 17, 
+    18, 19, 20, 21, 22, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 7, 32, 
+    7, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 47, 
+    48, 49, 50, 51, 52, 35, 47, 53, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 
+    58, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 80, 81, 
+    84, 85, 80, 86, 87, 88, 89, 90, 91, 92, 35, 93, 94, 95, 35, 96, 97, 
+    98, 99, 100, 101, 102, 35, 47, 103, 104, 35, 35, 105, 106, 107, 47, 
+    47, 108, 47, 47, 109, 47, 110, 111, 47, 112, 47, 113, 114, 115, 116, 
+    114, 47, 117, 118, 35, 47, 47, 119, 90, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 120, 121, 47, 47, 122, 
+    35, 35, 35, 35, 47, 123, 124, 125, 126, 47, 127, 128, 47, 129, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 7, 7, 7, 7, 130, 7, 7, 131, 132, 133, 134, 
+    135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 
+    149, 150, 151, 152, 153, 154, 155, 156, 156, 156, 156, 156, 156, 156, 
+    157, 158, 159, 160, 161, 162, 35, 35, 35, 160, 163, 164, 165, 166, 
+    167, 168, 169, 160, 160, 160, 160, 170, 171, 172, 173, 174, 160, 160, 
+    175, 35, 35, 35, 35, 176, 177, 178, 179, 180, 181, 35, 35, 160, 160, 
+    160, 160, 160, 160, 160, 160, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    182, 160, 160, 155, 160, 160, 160, 160, 160, 160, 170, 183, 184, 185, 
+    90, 47, 186, 90, 47, 187, 188, 189, 47, 47, 190, 128, 35, 35, 191, 
+    192, 193, 194, 192, 195, 196, 197, 160, 160, 160, 198, 160, 160, 199, 
+    197, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 200, 35, 35, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 201, 35, 35, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    202, 203, 204, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 205, 35, 35, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
+    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
+    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
+    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 
+    206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 47, 47, 47, 47, 47, 47, 47, 47, 47, 208, 35, 35, 35, 35, 
+    35, 35, 209, 210, 211, 47, 47, 212, 213, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 214, 215, 47, 216, 47, 217, 218, 35, 219, 220, 221, 47, 
+    47, 47, 222, 223, 2, 224, 225, 226, 227, 228, 229, 230, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 231, 35, 232, 233, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 208, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 47, 234, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 235, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 
+    207, 207, 207, 236, 207, 207, 207, 207, 207, 207, 207, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 
+    35, 35, 35, 35, 35
+};
+
+/*
+ * The groupMap is indexed by combining the alternate page number with
+ * the page offset and returns a group number that identifies a unique
+ * set of character attributes.
+ */
+
+static unsigned char groupMap[] = {
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 3, 3, 3, 5, 6, 3, 7, 3, 8, 
+    3, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 7, 7, 7, 3, 3, 10, 10, 10, 
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+    10, 10, 10, 10, 10, 10, 5, 3, 6, 11, 12, 11, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 5, 7, 6, 7, 1, 2, 3, 4, 4, 4, 4, 14, 14, 11, 14, 15, 16, 
+    7, 8, 14, 11, 14, 7, 17, 17, 11, 18, 14, 3, 11, 17, 15, 19, 17, 17, 
+    17, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+    10, 10, 10, 10, 10, 10, 10, 10, 7, 10, 10, 10, 10, 10, 10, 10, 15, 
+    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 13, 13, 13, 7, 13, 13, 13, 13, 13, 13, 13, 20, 21, 22, 
+    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
+    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
+    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 23, 24, 21, 22, 21, 
+    22, 21, 22, 15, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
+    22, 21, 22, 15, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
+    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
+    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 25, 
+    21, 22, 21, 22, 21, 22, 26, 15, 27, 21, 22, 21, 22, 28, 21, 22, 29, 
+    29, 21, 22, 15, 30, 31, 32, 21, 22, 29, 33, 34, 35, 36, 21, 22, 15, 
+    15, 35, 37, 15, 38, 21, 22, 21, 22, 21, 22, 39, 21, 22, 39, 15, 15, 
+    21, 22, 39, 21, 22, 40, 40, 21, 22, 21, 22, 41, 21, 22, 15, 42, 21, 
+    22, 15, 43, 42, 42, 42, 42, 44, 45, 46, 44, 45, 46, 44, 45, 46, 21, 
+    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 47, 21, 
+    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
+    15, 44, 45, 46, 21, 22, 48, 49, 21, 22, 21, 22, 21, 22, 21, 22, 0, 
+    0, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
+    21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 50, 51, 15, 52, 52, 15, 53, 15, 
+    54, 15, 15, 15, 15, 52, 15, 15, 55, 15, 15, 15, 15, 56, 57, 15, 15, 
+    15, 15, 15, 57, 15, 15, 58, 15, 15, 59, 15, 15, 15, 15, 15, 15, 15, 
+    15, 15, 15, 60, 15, 15, 60, 15, 15, 15, 15, 60, 15, 61, 61, 15, 15, 
+    15, 15, 15, 15, 62, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 63, 
+    63, 63, 63, 63, 63, 63, 63, 63, 11, 11, 63, 63, 63, 63, 63, 63, 63, 
+    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 63, 11, 
+    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 63, 63, 63, 
+    63, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 65, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 
+    64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, 
+    0, 0, 0, 0, 63, 0, 0, 0, 3, 0, 0, 0, 0, 0, 11, 11, 66, 3, 67, 67, 67, 
+    0, 68, 0, 69, 69, 15, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+    10, 10, 10, 10, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 70, 71, 
+    71, 71, 15, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 72, 13, 13, 13, 13, 13, 13, 13, 13, 13, 73, 74, 74, 0, 
+    75, 76, 77, 77, 77, 78, 79, 15, 0, 0, 21, 22, 21, 22, 21, 22, 21, 22, 
+    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 80, 81, 47, 
+    15, 82, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 84, 84, 84, 84, 84, 84, 
+    84, 84, 84, 84, 84, 84, 84, 84, 84, 10, 10, 10, 10, 10, 10, 10, 10, 
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+    10, 10, 10, 10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 13, 13, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 
+    81, 81, 81, 81, 21, 22, 14, 64, 64, 64, 64, 0, 85, 85, 0, 0, 21, 22, 
+    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
+    22, 77, 21, 22, 21, 22, 0, 0, 21, 22, 0, 0, 21, 22, 0, 0, 0, 21, 22, 
+    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 
+    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
+    21, 22, 0, 0, 21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 86, 86, 86, 86, 
+    86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 
+    86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 
+    0, 0, 63, 3, 3, 3, 3, 3, 3, 0, 87, 87, 87, 87, 87, 87, 87, 87, 87, 
+    87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 
+    87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 15, 0, 3, 8, 0, 0, 
+    0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 3, 64, 3, 64, 
+    64, 3, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 0, 0, 0, 0, 0, 42, 42, 42, 3, 3, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 0, 0, 0, 0, 0, 63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 0, 0, 64, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 3, 42, 64, 
+    64, 64, 64, 64, 64, 64, 85, 85, 64, 64, 64, 64, 64, 64, 63, 63, 64, 
+    64, 14, 64, 64, 64, 64, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 42, 42, 
+    42, 14, 14, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 88, 42, 
+    64, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 64, 64, 64, 64, 
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 
+    64, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 0, 0, 64, 42, 89, 89, 89, 64, 64, 64, 64, 64, 64, 
+    64, 64, 89, 89, 89, 89, 64, 0, 0, 42, 64, 64, 64, 64, 0, 0, 0, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 64, 64, 3, 3, 9, 9, 9, 9, 9, 9, 
+    9, 9, 9, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 
+    89, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 0, 0, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42, 0, 0, 0, 42, 
+    42, 42, 42, 0, 0, 64, 0, 89, 89, 89, 64, 64, 64, 64, 0, 0, 89, 89, 
+    0, 0, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 42, 42, 
+    0, 42, 42, 42, 64, 64, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 42, 42, 
+    4, 4, 17, 17, 17, 17, 17, 17, 14, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 42, 
+    42, 42, 42, 42, 42, 0, 0, 0, 0, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 
+    42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 0, 42, 42, 0, 42, 42, 0, 0, 
+    64, 0, 89, 89, 89, 64, 64, 0, 0, 0, 0, 64, 64, 0, 0, 64, 64, 64, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 0, 42, 0, 0, 0, 0, 0, 
+    0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 64, 64, 42, 42, 42, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 89, 0, 42, 42, 42, 42, 42, 42, 42, 
+    0, 42, 0, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 
+    42, 42, 0, 42, 42, 0, 42, 42, 42, 42, 42, 0, 0, 64, 42, 89, 89, 89, 
+    64, 64, 64, 64, 64, 0, 64, 64, 89, 0, 89, 89, 64, 0, 0, 42, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 9, 9, 9, 9, 
+    9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42, 
+    42, 0, 0, 42, 42, 42, 42, 0, 0, 64, 42, 89, 64, 89, 64, 64, 64, 0, 
+    0, 0, 89, 89, 0, 0, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 64, 89, 0, 
+    0, 0, 0, 42, 42, 0, 42, 42, 42, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 
+    9, 9, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 89, 
+    0, 42, 42, 42, 42, 42, 42, 0, 0, 0, 42, 42, 42, 0, 42, 42, 42, 42, 
+    0, 0, 0, 42, 42, 0, 42, 0, 42, 42, 0, 0, 0, 42, 42, 0, 0, 0, 42, 42, 
+    42, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 0, 0, 0, 
+    0, 89, 89, 64, 89, 89, 0, 0, 0, 89, 89, 89, 0, 89, 89, 89, 64, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 89, 89, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 
+    42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 0, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 89, 89, 
+    89, 89, 0, 64, 64, 64, 0, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 64, 
+    64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 
+    9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 
+    89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 0, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 
+    42, 42, 0, 0, 0, 0, 89, 64, 89, 89, 89, 89, 89, 0, 64, 89, 89, 0, 89, 
+    89, 64, 64, 0, 0, 0, 0, 0, 0, 0, 89, 89, 0, 0, 0, 0, 0, 0, 0, 42, 0, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 89, 89, 89, 64, 64, 
+    64, 0, 0, 89, 89, 89, 0, 89, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 89, 0, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 0, 0, 
+    42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 64, 0, 0, 0, 0, 89, 89, 89, 64, 
+    64, 64, 0, 64, 0, 89, 89, 89, 89, 89, 89, 89, 89, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 89, 3, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 64, 42, 42, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 4, 42, 42, 
+    42, 42, 42, 42, 63, 64, 64, 64, 64, 64, 64, 64, 64, 3, 9, 9, 9, 9, 
+    9, 9, 9, 9, 9, 9, 3, 3, 0, 0, 0, 0, 0, 42, 42, 0, 42, 0, 0, 42, 42, 
+    0, 42, 0, 0, 42, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 0, 42, 42, 42, 42, 
+    42, 42, 42, 0, 42, 42, 42, 0, 42, 0, 42, 0, 0, 42, 42, 0, 42, 42, 42, 
+    42, 64, 42, 42, 64, 64, 64, 64, 64, 64, 0, 64, 64, 42, 0, 0, 42, 42, 
+    42, 42, 42, 0, 63, 0, 64, 64, 64, 64, 64, 64, 0, 0, 9, 9, 9, 9, 9, 
+    9, 9, 9, 9, 9, 0, 0, 42, 42, 0, 0, 42, 14, 14, 14, 3, 3, 3, 3, 3, 3, 
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 14, 14, 14, 14, 14, 64, 64, 14, 14, 14, 
+    14, 14, 14, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 14, 64, 14, 64, 14, 64, 5, 6, 5, 6, 89, 89, 42, 42, 42, 
+    42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 64, 64, 64, 64, 89, 64, 64, 64, 64, 64, 3, 64, 64, 42, 
+    42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    0, 14, 14, 14, 14, 14, 14, 14, 14, 64, 14, 14, 14, 14, 14, 14, 0, 0, 
+    14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 0, 42, 
+    42, 42, 42, 42, 0, 42, 42, 0, 89, 64, 64, 64, 64, 89, 64, 0, 0, 0, 
+    64, 64, 89, 64, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 
+    3, 3, 3, 3, 3, 42, 42, 42, 42, 42, 42, 89, 89, 64, 64, 0, 0, 0, 0, 
+    0, 0, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 
+    77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 
+    77, 77, 77, 77, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    0, 0, 0, 0, 3, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 
+    0, 0, 0, 0, 42, 42, 42, 42, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 42, 42, 42, 
+    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 
+    0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42, 
+    0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 
+    42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 0, 
+    42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 
+    3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 3, 3, 42, 42, 42, 42, 42, 
+    42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 5, 6, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    3, 3, 3, 90, 90, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 89, 89, 89, 64, 64, 64, 64, 64, 64, 64, 89, 89, 89, 89, 89, 
+    89, 89, 89, 64, 89, 89, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    3, 3, 3, 3, 3, 3, 3, 4, 3, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 
+    3, 3, 3, 3, 8, 3, 3, 3, 3, 88, 88, 88, 88, 0, 9, 9, 9, 9, 9, 9, 9, 
+    9, 9, 9, 0, 0, 0, 0, 0, 0, 42, 42, 42, 63, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 
+    0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 64, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 21, 22, 21, 22, 21, 
+    22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 15, 15, 
+    15, 15, 15, 91, 0, 0, 0, 0, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 
+    21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 0, 
+    0, 0, 0, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 
+    93, 93, 93, 92, 92, 92, 92, 92, 92, 0, 0, 93, 93, 93, 93, 93, 93, 0, 
+    0, 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 
+    92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 92, 
+    92, 92, 92, 92, 92, 0, 0, 93, 93, 93, 93, 93, 93, 0, 0, 15, 92, 15, 
+    92, 15, 92, 15, 92, 0, 93, 0, 93, 0, 93, 0, 93, 92, 92, 92, 92, 92, 
+    92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 94, 94, 95, 95, 95, 95, 
+    96, 96, 97, 97, 98, 98, 99, 99, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 
+    100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 92, 92, 92, 92, 92, 
+    92, 100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 92, 92, 92, 92, 
+    92, 92, 100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 15, 101, 15, 
+    0, 15, 15, 93, 93, 102, 102, 103, 11, 104, 11, 11, 11, 15, 101, 15, 
+    0, 15, 15, 105, 105, 105, 105, 103, 11, 11, 11, 92, 92, 15, 15, 0, 
+    0, 15, 15, 93, 93, 106, 106, 0, 11, 11, 11, 92, 92, 15, 15, 15, 107, 
+    15, 15, 93, 93, 108, 108, 109, 11, 11, 11, 0, 0, 15, 101, 15, 0, 15, 
+    15, 110, 110, 111, 111, 103, 11, 11, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
+    2, 2, 2, 88, 88, 88, 88, 8, 8, 8, 8, 8, 8, 3, 3, 16, 19, 5, 16, 16, 
+    19, 5, 16, 3, 3, 3, 3, 3, 3, 3, 3, 112, 113, 88, 88, 88, 88, 88, 2, 
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 16, 19, 3, 3, 3, 3, 12, 12, 3, 3, 3, 7, 
+    5, 6, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 88, 88, 88, 88, 88, 17, 
+    0, 0, 0, 17, 17, 17, 17, 17, 17, 7, 7, 7, 5, 6, 15, 17, 17, 17, 17, 
+    17, 17, 17, 17, 17, 17, 7, 7, 7, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
+    64, 64, 64, 85, 85, 85, 85, 64, 85, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 77, 
+    14, 14, 14, 14, 77, 14, 14, 15, 77, 77, 77, 15, 15, 77, 77, 77, 15, 
+    14, 77, 14, 14, 14, 77, 77, 77, 77, 77, 14, 14, 14, 14, 14, 14, 77, 
+    14, 114, 14, 77, 14, 115, 116, 77, 77, 14, 15, 77, 77, 14, 77, 15, 
+    42, 42, 42, 42, 15, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 
+    117, 117, 117, 117, 117, 118, 118, 118, 118, 118, 118, 118, 118, 118, 
+    118, 118, 118, 118, 118, 118, 118, 90, 90, 90, 90, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 7, 7, 14, 14, 
+    14, 14, 7, 14, 14, 7, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 7, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 14, 14, 7, 
+    14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
+    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 7, 7, 14, 14, 14, 14, 14, 14, 14, 5, 6, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 119, 119, 119, 119, 119, 119, 
+    119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 
+    119, 119, 119, 119, 119, 119, 120, 120, 120, 120, 120, 120, 120, 120, 
+    120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 
+    120, 120, 120, 120, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 7, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 
+    14, 14, 14, 0, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 0, 14, 0, 14, 14, 14, 14, 0, 0, 0, 14, 0, 14, 14, 
+    14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 
+    0, 0, 0, 2, 3, 3, 3, 14, 63, 42, 90, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 
+    14, 14, 5, 6, 5, 6, 5, 6, 5, 6, 8, 5, 6, 6, 14, 90, 90, 90, 90, 90, 
+    90, 90, 90, 90, 64, 64, 64, 64, 64, 64, 8, 63, 63, 63, 63, 63, 14, 
+    14, 90, 90, 90, 0, 0, 0, 14, 14, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 
+    11, 11, 63, 63, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 12, 63, 
+    63, 63, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 14, 14, 17, 17, 17, 
+    17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 0, 14, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, 121, 121, 121, 121, 121, 121, 
+    121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 
+    121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 122, 122, 122, 
+    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
+    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
+    122, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 
+    15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 0, 
+    0, 0, 0, 0, 42, 64, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 7, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 
+    42, 0, 42, 0, 42, 42, 0, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 64, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 8, 8, 12, 12, 5, 6, 5, 6, 5, 
+    6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 0, 0, 3, 3, 3, 3, 12, 12, 12, 
+    3, 3, 3, 0, 3, 3, 3, 3, 8, 5, 6, 5, 6, 5, 6, 3, 3, 3, 7, 8, 7, 7, 7, 
+    0, 3, 4, 3, 3, 0, 0, 0, 0, 42, 42, 42, 0, 42, 0, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    0, 0, 88, 0, 3, 3, 3, 4, 3, 3, 3, 5, 6, 3, 7, 3, 8, 3, 3, 9, 9, 9, 
+    9, 9, 9, 9, 9, 9, 9, 3, 3, 7, 7, 7, 3, 11, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+    13, 13, 13, 5, 7, 6, 7, 0, 0, 3, 5, 6, 3, 12, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 63, 
+    63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 
+    42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 
+    42, 42, 42, 42, 0, 0, 42, 42, 42, 0, 0, 0, 4, 4, 7, 11, 14, 4, 4, 0, 
+    14, 7, 7, 7, 7, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 88, 88, 14, 
+    14, 42, 17, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 123, 123, 123, 
+    126, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 89, 64, 14, 14, 14, 
+    14, 14, 0, 0, 77, 77, 15, 15, 77, 15, 15, 77, 77, 15, 77, 77, 15, 77, 
+    77, 15, 15, 77, 15, 15, 77, 77, 15, 77, 77, 15, 77, 77, 15, 15, 77, 
+    15, 15, 77, 77, 15, 77, 77, 15, 77, 77, 15, 15, 77, 77, 15, 15, 77, 
+    15, 15, 77, 77, 15, 15, 77, 15, 15, 77, 77, 15, 15, 9, 9, 9, 42, 42, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 88, 0, 88, 88, 88, 88, 88, 88, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 122, 
+    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
+    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 
+    122
+};
+
+/*
+ * Each group represents a unique set of character attributes.  The attributes
+ * are encoded into a 32-bit value as follows:
+ *
+ * Bits 0-4	Character category: see the constants listed below.
+ *
+ * Bits 5-7	Case delta type: 000 = identity
+ *				 010 = add delta for lower
+ *				 011 = add delta for lower, add 1 for title
+ *				 100 = sutract delta for title/upper
+ *				 101 = sub delta for upper, sub 1 for title
+ *				 110 = sub delta for upper, add delta for lower
+ *
+ * Bits 8-21	Reserved for future use.
+ *
+ * Bits 22-31	Case delta: delta for case conversions.  This should be the
+ *			    highest field so we can easily sign extend.
+ */
+
+static int groups[] = {
+    0, 15, 12, 25, 27, 21, 22, 26, 20, 9, 134217793, 28, 19, 134217858, 
+    29, 2, 23, 11, 1178599554, 24, -507510654, 4194369, 4194434, -834666431, 
+    973078658, -507510719, 1258291330, 880803905, 864026689, 859832385, 
+    331350081, 847249473, 851443777, 868220993, -406847358, 884998209, 
+    876609601, 893386817, 897581121, 914358337, 910164033, 918552641, 
+    5, -234880894, 8388705, 4194499, 8388770, 331350146, -406847423, 
+    -234880959, 880803970, 864026754, 859832450, 847249538, 851443842, 
+    868221058, 876609666, 884998274, 893386882, 897581186, 914358402, 
+    910164098, 918552706, 4, 6, -352321402, 159383617, 155189313, 
+    268435521, 264241217, 159383682, 155189378, 130023554, 268435586, 
+    264241282, 260046978, 239075458, 1, 197132418, 226492546, 360710274, 
+    335544450, -251658175, 402653314, 335544385, 7, 201326657, 201326722, 
+    16, 8, 10, 247464066, -33554302, -33554367, -310378366, -360710014, 
+    -419430270, -536870782, -469761918, -528482174, -33554365, -37748606, 
+    -310378431, -37748669, 155189378, -360710079, -419430335, -29359998, 
+    -469761983, -29360063, -536870847, -528482239, 13, 14, -1463812031, 
+    -801111999, -293601215, 67108938, 67109002, 109051997, 109052061, 
+    18, 17, 8388673, 12582977, 8388738, 12583042
+};
+
+/*
+ * The following constants are used to determine the category of a
+ * Unicode character.
+ */
+
+#define UNICODE_CATEGORY_MASK 0X1F
+
+enum {
+    UNASSIGNED,
+    UPPERCASE_LETTER,
+    LOWERCASE_LETTER,
+    TITLECASE_LETTER,
+    MODIFIER_LETTER,
+    OTHER_LETTER,
+    NON_SPACING_MARK,
+    ENCLOSING_MARK,
+    COMBINING_SPACING_MARK,
+    DECIMAL_DIGIT_NUMBER,
+    LETTER_NUMBER,
+    OTHER_NUMBER,
+    SPACE_SEPARATOR,
+    LINE_SEPARATOR,
+    PARAGRAPH_SEPARATOR,
+    CONTROL,
+    FORMAT,
+    PRIVATE_USE,
+    SURROGATE,
+    CONNECTOR_PUNCTUATION,
+    DASH_PUNCTUATION,
+    OPEN_PUNCTUATION,
+    CLOSE_PUNCTUATION,
+    INITIAL_QUOTE_PUNCTUATION,
+    FINAL_QUOTE_PUNCTUATION,
+    OTHER_PUNCTUATION,
+    MATH_SYMBOL,
+    CURRENCY_SYMBOL,
+    MODIFIER_SYMBOL,
+    OTHER_SYMBOL
+};
+
+/*
+ * The following macros extract the fields of the character info.  The
+ * GetDelta() macro is complicated because we can't rely on the C compiler
+ * to do sign extension on right shifts.
+ */
+
+#define GetCaseType(info) (((info) & 0xE0) >> 5)
+#define GetCategory(info) ((info) & 0x1F)
+#define GetDelta(info) (((info) > 0) ? ((info) >> 22) : (~(~((info)) >> 22)))
+
+/*
+ * This macro extracts the information about a character from the
+ * Unicode character tables.
+ */
+
+#define GetUniCharInfo(ch) (groups[groupMap[(pageMap[(((int)(ch)) & 0xffff) >> OFFSET_BITS] << OFFSET_BITS) | ((ch) & ((1 << OFFSET_BITS)-1))]])
+

utils/wxPython/.cvsignore

@@ -1,97 +0,0 @@
-*.zip
-.cvsignore
-.emacs.desktop
-__init__.py
-__init__.py
-__init__.pyc
-__init__.pyc
-__init__.pyo
-__init__.pyo
-cmndlgs.py
-cmndlgs.py
-cmndlgs.pyc
-cmndlgs.pyc
-cmndlgs.pyo
-cmndlgs.pyo
-controls.py
-controls.py
-controls.pyc
-controls.pyc
-controls.pyo
-controls.pyo
-controls2.py
-controls2.py
-controls2.pyc
-controls2.pyc
-controls2.pyo
-controls2.pyo
-events.py
-events.py
-events.pyc
-events.pyc
-events.pyo
-events.pyo
-frames.py
-frames.py
-frames.pyc
-frames.pyc
-frames.pyo
-frames.pyo
-gdi.py
-gdi.py
-gdi.pyc
-gdi.pyc
-gdi.pyo
-gdi.pyo
-mdi.py
-mdi.py
-mdi.pyc
-mdi.pyc
-mdi.pyo
-mdi.pyo
-misc.py
-misc.py
-misc.pyc
-misc.pyc
-misc.pyo
-misc.pyo
-stattool.py
-stattool.py
-stattool.pyc
-stattool.pyc
-stattool.pyo
-stattool.pyo
-utils.py
-utils.py
-utils.pyc
-utils.pyc
-utils.pyo
-windows.py
-windows.py
-windows.pyc
-windows.pyc
-windows.pyo
-windows.pyo
-windows2.py
-windows2.py
-windows2.pyc
-windows2.pyc
-windows2.pyo
-windows2.pyo
-windows3.py
-windows3.pyc
-windows3.pyo
-wx.py
-wx.py
-wx.pyc
-wx.pyc
-wx.pyo
-wxc.ilk
-wxc.pdb
-wxc.pyd
-wxp.py
-wxp.pyc
-wxp.pyo
-wxpc.ilk
-wxpc.pdb
-wxpc.pyd

utils/wxPython/README.txt

@@ -1,204 +0,0 @@
-wxPython README
----------------
-
-Introduction
-------------
-The code in this subtree is a Python Extension Module that enables the
-use of wxWindows from the Python language.  So what is Python?  Go to
-http://www.python.org to learn more but in a nutshell, it's an
-extremly cool object oriented language.  It's easier than Perl and
-nearly as powerful.  It runs on more platforms than Java, and by some
-reports, is even faster than Java with a JIT compiler!
-
-So why would you want to use wxPython over just C++ and wxWindows?
-Personally I prefer using Python for everything.  I only use C++ when
-I absolutly have to eek more performance out of an algorithm, and even
-then I ususally code it as an extension module and leave the majority
-of the program in Python.  Another good thing to use wxPython for is
-quick prototyping of your wxWindows apps.  With C++ you have to
-continuously go though the edit-compile-link-run cycle, which can be
-quite time comsuming.  With Python it is only an edit-run cycle.  You
-can easily build an application in a few hours with Python that would
-normally take a few days with C++.  Converting a wxPython app to a
-C++/wxWindows app should be a straight forward task.
-
-This extension module attempts to mirror the class heiarchy of
-wxWindows as closely as possble.  This means that there is a wxFrame
-class in wxPython that looks, smells, tastes and acts almost the same
-as the wxFrame class in the C++ version.  Unfortunatly, I wasn't able
-to match things exactly because of differences in the languages, but
-the differences should be easy to absorb because they are natural to
-Python.  For example, some methods that return mutliple values via
-argument pointers in C++ will return a tuple of values in Python.
-These differences have not been documented yet so if something isn't
-working the same as described in the wxWindows documents the best
-thing to do is to scan through the wxPython sources, especially the .i
-files, as that is where the interfaces for wxPython are defined.
-
-Currently this extension module is designed such that the entire
-application will be written in Python.  I havn't tried it yet, but I
-am sure that attempting to embed wxPython in a C++ wxWindows
-application will cause problems.  However there is a plan to support
-this in the future.
-
-
-What's new in 0.5.3
--------------------
-Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-
-Various cleanup, tweaks, minor additions, etc. to maintain
-compatibility with the current wxWindows.
-
-
-
-What's new in 0.5.0
--------------------
-Changed the import semantics from "from wxPython import *" to "from
-wxPython.wx import *"  This is for people who are worried about
-namespace pollution, they can use "from wxPython import wx" and then
-prefix all the wxPython identifiers with "wx."
-
-Added wxTaskbarIcon for wxMSW.
-
-Made the events work for wxGrid.
-
-Added wxConfig.
-
-Added wxMiniFrame for wxGTK.
-
-Changed many of the args and return values that were pointers to gdi
-objects to references to reflect changes in the wxWindows API.
-
-Other assorted fixes and additions.
-
-
-
-
-What's new in 0.4.2
--------------------
-
-wxPython on wxGTK works!!!  Both dynamic and static on Linux and
-static on Solaris have been tested.  Many thanks go to Harm
-<H.v.d.Heijden@phys.tue.nl> for his astute detective work on tracking
-down a nasty DECREF bug.  Okay so I have to confess that it was just a
-DSM (Dumb Stupid Mistake) on my part but it was nasty none the less
-because the behavior was so different on different platforms.
-
-
-The dynamicly loaded module on Solaris is still segfaulting, so it
-must have been a different issue all along...
-
-
-
-What's New in 0.4
------------------
-
-1. Worked on wxGTK compatibility.  It is partially working.  On a
-Solaris/Sparc box wxPython is working but only when it is statically
-linked with the Python interpreter.  When built as a dyamically loaded
-extension module, things start acting weirdly and it soon seg-faults.
-And on Linux both the statically linked and the dynamically linked
-version segfault shortly after starting up.
-
-2. Added Toolbar, StatusBar and SplitterWindow classes.
-
-3. Varioius bug fixes, enhancements, etc.
-
-
-
-Build Instructions
-------------------
-I used SWIG (http://www.swig.org) to create the source code for the
-extension module.  This enabled me to only have to deal with a small
-amount of code and only have to bother with the exceptional issues.
-SWIG takes care of the rest and generates all the repetative code for
-me.  You don't need SWIG to build the extension module as all the
-generated C++ code is included under the src directory.
-
-I added a few minor features to SWIG to control some of the code
-generation.  If you want to playaround with this the patches are in
-wxPython/SWIG.patches and they should be applied to the 1.1p5 version
-of SWIG.  These new patches are documented at
-http://starship.skyport.net/crew/robind/python/#swig, and they should
-also end up in the 1.2 version of SWIG.
-
-wxPython is organized as a Python package.  This means that the
-directory containing the results of the build process should be a
-subdirectory of a directory on the PYTHONPATH.  (And preferably should
-be named wxPython.)  You can control where the build process will dump
-wxPython by setting the TARGETDIR makefile variable.  The default is
-$(WXWIN)/utils/wxPython, where this README.txt is located.  If you
-leave it here then you should add $(WXWIN)/utils to your PYTHONPATH.
-However, you may prefer to use something that is already on your
-PYTHONPATH, such as the site-packages directory on Unix systems.
-
-
-Win32
------
-
-1. Build wxWindows with wxUSE_RESOURCE_LOADING_IN_MSW set to 1 in
-include/wx/msw/setup.h so icons can be loaded dynamically.  While
-there, make sure wxUSE_OWNER_DRAWN is also set to 1.
-
-2. Change into the $(WXWIN)/utils/wxPython/src directory.
-
-3. Edit makefile.nt and specify where your python installation is at.
-You may also want to fiddle with the TARGETDIR variable as described
-above.
-
-4. Run nmake -f makefile.nt
-
-5. If it builds successfully, congratulations!  Move on to the next
-step.  If not then you can try mailing me for help.  Also, I will
-always have a pre-built win32 version of this extension module at
-http://starship.skyport.net/crew/robind/python.
-
-6. Change to the $(WXWIN)/utils/wxPython/tests directory.
-
-7. Try executing the test programs.  Note that some of these print
-diagnositc or test info to standard output, so they will require the
-console version of python.  For example:
-
-    python test1.py
-
-To run them without requiring a console, you can use the pythonw.exe
-version of Python either from the command line or from a shortcut.
-
-
-
-Unix
-----
-
-1. Change into the $(WXWIN)/utils/wxPython/src directory.
-
-2. Edit Setup.in and ensure that the flags, directories, and toolkit
-options are correct.  See the above commentary about TARGETDIR.  There
-are a few sample Setup.in.[platform] files provided.
-
-3. Run this command to generate a makefile:
-
-    make -f Makefile.pre.in boot
-
-4. Run these commands to build and then install the wxPython extension
-module:
-
-    make
-    make install
-
-
-5. Change to the $(WXWIN)/utils/wxPython/tests directory.
-
-6. Try executing the test programs.  For example:
-
-    python test1.py
-
-
-
-------------------------
-10/20/1998
-
-Robin Dunn
-robin@alldunn.com
-
-
-

utils/wxPython/SWIG.patches/Include.patch

@@ -1,97 +0,0 @@
-*** swig.h.old	Wed Feb 04 14:59:40 1998
---- swig.h	Fri Aug 28 14:46:32 1998
-***************
-*** 178,185 ****
---- 178,211 ----
-    char  *firstkey();
-    char  *nextkey();
-  };
-  
-+ // -------------------------------------------------------------------
-+ // Simple Vector class
-+ // User is responsible for deleting contents before deleteing Vector
-+ // -------------------------------------------------------------------
-+ 
-+ class Vector {
-+ public:
-+     Vector(size_t allocSize=8);
-+     ~Vector();
-+ 
-+     size_t size()                      { return m_size;  }
-+     size_t count()                     { return m_count; }
-+     size_t append(void* object);
-+     size_t extend(size_t newSize);
-+ 
-+     void*& operator[] (size_t idx);
-+ 
-+     static void*    s_nullPtr;
-+ 
-+ private:
-+     size_t          m_size;
-+     size_t          m_count;
-+     void**          m_data;
-+ };
-+ 
-+ 
-  /************************************************************************
-   * class DataType
-   *
-   * Defines the basic datatypes supported by the translator.
-***************
-*** 684,691 ****
---- 710,761 ----
-  extern char  *name_get(char *vname, int suppress=0);
-  extern char  *name_set(char *vname, int suppress=0);
-  extern char  *name_construct(char *classname, int suppress=0);
-  extern char  *name_destroy(char *classname, int suppress=0);
-+ 
-+ // ----------------------------------------------------------------------
-+ // class CPP_class
-+ //
-+ // Class for managing class members (internally)
-+ // ----------------------------------------------------------------------
-+ 
-+ class CPP_member;
-+ 
-+ class CPP_class {
-+ public:
-+   char        *classname;             // Real class name
-+   char        *classrename;           // New name of class (if applicable)
-+   char        *classtype;             // class type (struct, union, class)
-+   int          strip;                 // Strip off class declarator
-+   int          wextern;               // Value of extern wrapper variable for this class
-+   int          have_constructor;      // Status bit indicating if we've seen a constructor
-+   int          have_destructor;       // Status bit indicating if a destructor has been seen
-+   int          is_abstract;           // Status bit indicating if this is an abstract class
-+   int          generate_default;      // Generate default constructors
-+   int          objective_c;           // Set if this is an objective C class
-+   int          error;                 // Set if this class can't be generated
-+   int          line;                  // Line number
-+   char        **baseclass;            // Base classes (if any)
-+   Hash        *local;                 // Hash table for local types
-+   Hash        *scope;                 // Local scope hash table
-+   DocEntry    *de;                    // Documentation entry of class
-+   CPP_member  *members;               // Linked list of members
-+   CPP_class   *next;                  // Next class
-+   static CPP_class *classlist;        // List of all classes stored
-+ 
-+   Vector      addPragmas;
-+ 
-+   CPP_class(char *name, char *ctype);
-+   void add_member(CPP_member *m);
-+   CPP_member *search_member(char *name);
-+   void inherit_decls(int mode);
-+   void emit_decls();
-+   static CPP_class *search(char *name);
-+   void create_default();
-+   static void create_all();
-+ };
-+ 
-+ extern CPP_class     *current_class;
-  
-  /***********************************************************************
-   * -- Revision History
-   * $Log$
-   * Revision 1.1  1998/10/03 05:56:02  RD
-   * *** empty log message ***
-   *

utils/wxPython/SWIG.patches/Modules.patch

@@ -1,136 +0,0 @@
-*** python.cxx.old	Fri Jan 02 22:17:40 1998
---- python.cxx	Fri Aug 28 14:49:18 1998
-***************
-*** 1679,1684 ****
---- 1679,1701 ----
-  	      }
-  	    }
-  	  }
-+         } else if (strcmp(cmd, "addtomethod") == 0) {
-+             // parse value, expected to be in the form "methodName:line"
-+             char* txtptr = strchr(value, ':');
-+             if (txtptr) {
-+                 // add name and line to a list in current_class
-+                 *txtptr = 0;
-+                 txtptr++;
-+                 AddPragmaData* apData = new AddPragmaData(value, txtptr);
-+                 current_class->addPragmas.append(apData);
-+ 
-+             } else {
-+                 fprintf(stderr,"%s : Line %d. Malformed addtomethod pragma.  Should be \"methodName:text\"\n",
-+                         input_file, line_number);
-+             }
-+         } else if (strcmp(cmd, "addtoclass") == 0) {
-+                 AddPragmaData* apData = new AddPragmaData("__class__", value);
-+                 current_class->addPragmas.append(apData);
-  	} else {
-  	  fprintf(stderr,"%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
-  	}
-*** python.h.old	Thu Jul 24 22:18:50 1997
---- python.h	Fri Aug 28 14:46:08 1998
-***************
-*** 185,191 ****
---- 185,203 ----
-    void cpp_class_decl(char *, char *,char *);
-    void pragma(char *, char *, char *);
-    void add_typedef(DataType *t, char *name);
-+ 
-+   void emitAddPragmas(String& output, char* name, char* spacing);
-  };
-  
-  #define PYSHADOW_MEMBER  0x2
-+ 
-+ struct AddPragmaData {
-+     String      m_method;
-+     String      m_text;
-+ 
-+     AddPragmaData(char* method, char* text)
-+         : m_method(method),
-+           m_text(text)
-+         {}
-+ };
-  
-*** pycpp.cxx.old	Fri Jan 02 20:23:22 1998
---- pycpp.cxx	Fri Aug 28 16:01:46 1998
-***************
-*** 276,281 ****
---- 276,282 ----
-        }
-      }
-      //    if ((t->type != T_VOID) || (t->is_pointer))
-+     emitAddPragmas(*pyclass, realname, tab8);
-      *pyclass << tab8 << "return val\n";
-  
-      // Change the usage string to reflect our shadow class
-***************
-*** 394,399 ****
---- 395,401 ----
-        }
-        *construct << ")\n";
-        *construct << tab8 << "self.thisown = 1\n";
-+       emitAddPragmas(*construct, "__init__", tab8);
-        have_constructor = 1;
-      } else {
-  
-***************
-*** 494,502 ****
-      *pyclass << tab4 << "def __del__(self):\n"
-  	     << tab8 << "if self.thisown == 1 :\n"
-  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
-!     
-      have_destructor = 1;
-- 
-      if (doc_entry) {
-        doc_entry->usage = "";
-        doc_entry->usage << "del this";
---- 496,503 ----
-      *pyclass << tab4 << "def __del__(self):\n"
-  	     << tab8 << "if self.thisown == 1 :\n"
-  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
-!     emitAddPragmas(*pyclass, "__del__", tab8);
-      have_destructor = 1;
-      if (doc_entry) {
-        doc_entry->usage = "";
-        doc_entry->usage << "del this";
-***************
-*** 552,557 ****
---- 553,560 ----
-  	   << tab8 << "return \"<C " << class_name <<" instance>\"\n";
-  
-        classes << repr;
-+       emitAddPragmas(classes, "__class__", tab4);
-+ 
-      }
-  
-      // Now build the real class with a normal constructor
-***************
-*** 747,752 ****
---- 750,777 ----
-    }
-  }
-  
-+ // --------------------------------------------------------------------------------
-+ // PYTHON::emitAddPragmas(String& output, char* name, char* spacing);
-+ //
-+ // Search the current_class->addPragmas vector for any text belonging to name.
-+ // Append the text properly spcaed to the output string.
-+ //
-+ // --------------------------------------------------------------------------------
-+ 
-+ void PYTHON::emitAddPragmas(String& output, char* name, char* spacing)
-+ {
-+     AddPragmaData*      apData;
-+     size_t              count;
-+     int                 i;
-+ 
-+     count = current_class->addPragmas.count();
-+     for (i=0; i<count; i++) {
-+         apData = (AddPragmaData*)current_class->addPragmas[i];
-+         if (strcmp(apData->m_method, name) == 0) {
-+             output << spacing << apData->m_text << "\n";
-+         }
-+     }
-+ }
-  
-  /*********************************************************************************
-   *

utils/wxPython/SWIG.patches/SWIG.patch

@@ -1,488 +0,0 @@
-*** cplus.cxx.old	Mon Feb 02 14:55:42 1998
---- cplus.cxx	Fri Aug 28 12:02:50 1998
-***************
-*** 581,612 ****
-  // Class for managing class members (internally)
-  // ----------------------------------------------------------------------
-  
-  static char   *inherit_base_class = 0;
-  
-- class CPP_class {
-- public:
--   char        *classname;             // Real class name
--   char        *classrename;           // New name of class (if applicable)
--   char        *classtype;             // class type (struct, union, class)
--   int          strip;                 // Strip off class declarator
--   int          wextern;               // Value of extern wrapper variable for this class
--   int          have_constructor;      // Status bit indicating if we've seen a constructor
--   int          have_destructor;       // Status bit indicating if a destructor has been seen
--   int          is_abstract;           // Status bit indicating if this is an abstract class
--   int          generate_default;      // Generate default constructors
--   int          objective_c;           // Set if this is an objective C class
--   int          error;                 // Set if this class can't be generated
--   int          line;                  // Line number
--   char        **baseclass;            // Base classes (if any)
--   Hash        *local;                 // Hash table for local types
--   Hash        *scope;                 // Local scope hash table
--   DocEntry    *de;                    // Documentation entry of class
--   CPP_member  *members;               // Linked list of members
--   CPP_class   *next;                  // Next class
--   static CPP_class *classlist;        // List of all classes stored
-  
-!   CPP_class(char *name, char *ctype) {
-      CPP_class *c;
-      classname = copy_string(name);
-      classtype = copy_string(ctype);
-      classrename = 0;
---- 581,593 ----
-  // Class for managing class members (internally)
-  // ----------------------------------------------------------------------
-  
-  static char   *inherit_base_class = 0;
-+ CPP_class *CPP_class::classlist = 0;
-+ CPP_class     *current_class;
-  
-  
-! CPP_class::CPP_class(char *name, char *ctype) {
-    CPP_class *c;
-    classname = copy_string(name);
-    classtype = copy_string(ctype);
-    classrename = 0;
-***************
-*** 642,650 ****
-    // ------------------------------------------------------------------------------
-    // Add a new C++ member to this class
-    // ------------------------------------------------------------------------------
-  
-!   void add_member(CPP_member *m) {
-      CPP_member *cm;
-      
-      // Set base class where this was defined
-      if (inherit_base_class)          
---- 623,631 ----
-  // ------------------------------------------------------------------------------
-  // Add a new C++ member to this class
-  // ------------------------------------------------------------------------------
-  
-! void CPP_class::add_member(CPP_member *m) {
-    CPP_member *cm;
-  
-    // Set base class where this was defined
-    if (inherit_base_class)
-***************
-*** 664,672 ****
-    // ------------------------------------------------------------------------------
-    // Search for a member with the given name. Returns the member on success, 0 on failure
-    // ------------------------------------------------------------------------------
-  
-!   CPP_member *search_member(char *name) {
-      CPP_member *m;
-      char *c;
-      m = members;
-      while (m) {
---- 645,653 ----
-  // ------------------------------------------------------------------------------
-  // Search for a member with the given name. Returns the member on success, 0 on failure
-  // ------------------------------------------------------------------------------
-  
-! CPP_member *CPP_class::search_member(char *name) {
-    CPP_member *m;
-    char *c;
-    m = members;
-    while (m) {
-***************
-*** 680,688 ****
-    // ------------------------------------------------------------------------------
-    // Inherit.  Put all the declarations associated with this class into the current
-    // ------------------------------------------------------------------------------
-  
-!   void inherit_decls(int mode) {
-      CPP_member *m;
-      m = members;
-      while (m) {
-        inherit_base_class = m->base;
---- 661,669 ----
-  // ------------------------------------------------------------------------------
-  // Inherit.  Put all the declarations associated with this class into the current
-  // ------------------------------------------------------------------------------
-  
-! void CPP_class::inherit_decls(int mode) {
-    CPP_member *m;
-    m = members;
-    while (m) {
-      inherit_base_class = m->base;
-***************
-*** 696,704 ****
-    // ------------------------------------------------------------------------------
-    // Emit all of the declarations associated with this class 
-    // ------------------------------------------------------------------------------
-  
-!   void emit_decls() {
-      CPP_member    *m = members;
-      int  last_scope = name_scope(0);
-      abstract = is_abstract;
-      while (m) {
---- 677,685 ----
-  // ------------------------------------------------------------------------------
-  // Emit all of the declarations associated with this class
-  // ------------------------------------------------------------------------------
-  
-! void CPP_class::emit_decls() {
-    CPP_member    *m = members;
-    int  last_scope = name_scope(0);
-    abstract = is_abstract;
-    while (m) {
-***************
-*** 713,721 ****
-    // ------------------------------------------------------------------------------  
-    // Search for a given class in the list
-    // ------------------------------------------------------------------------------
-  
-!   static CPP_class *search(char *name) {
-      CPP_class *c;
-      c = classlist;
-      if (!name) return 0;
-      while (c) {
---- 694,702 ----
-  // ------------------------------------------------------------------------------
-  // Search for a given class in the list
-  // ------------------------------------------------------------------------------
-  
-! CPP_class *CPP_class::search(char *name) {
-    CPP_class *c;
-    c = classlist;
-    if (!name) return 0;
-    while (c) {
-***************
-*** 729,737 ****
-    // Add default constructors and destructors
-    //
-    // ------------------------------------------------------------------------------
-  
-!   void create_default() {
-      if (!generate_default) return;
-      
-      // Try to generate a constructor if not available.
-  
---- 710,718 ----
-  // Add default constructors and destructors
-  //
-  // ------------------------------------------------------------------------------
-  
-! void CPP_class::create_default() {
-    if (!generate_default) return;
-  
-    // Try to generate a constructor if not available.
-  
-***************
-*** 751,764 ****
-    // ------------------------------------------------------------------------------
-    // Dump *all* of the classes saved out to the various
-    // language modules (this does what cplus_close_class used to do)
-    // ------------------------------------------------------------------------------
--   static void create_all();
-- };
-- 
-- CPP_class *CPP_class::classlist = 0;
-- static CPP_class     *current_class;
-- 
-  void CPP_class::create_all() {
-    CPP_class *c;
-    c = classlist;
-    while (c) {
---- 732,739 ----
-*** vector.cxx.old	Fri Aug 28 14:23:16 1998
---- vector.cxx	Fri Aug 28 14:46:52 1998
-***************
-*** 0 ****
---- 1,182 ----
-+ 
-+ /*******************************************************************************
-+  * Simplified Wrapper and Interface Generator  (SWIG)
-+  *
-+  * Dave Beazley
-+  *
-+  * Department of Computer Science        Theoretical Division (T-11)
-+  * University of Utah                    Los Alamos National Laboratory
-+  * Salt Lake City, Utah  84112           Los Alamos, New Mexico  87545
-+  * beazley@cs.utah.edu                   beazley@lanl.gov
-+  *
-+  * Copyright (c) 1995-1997
-+  * The University of Utah and the Regents of the University of California
-+  * All Rights Reserved
-+  *
-+  * Permission is hereby granted, without written agreement and without
-+  * license or royalty fees, to use, copy, modify, and distribute this
-+  * software and its documentation for any purpose, provided that
-+  * (1) The above copyright notice and the following two paragraphs
-+  * appear in all copies of the source code and (2) redistributions
-+  * including binaries reproduces these notices in the supporting
-+  * documentation.   Substantial modifications to this software may be
-+  * copyrighted by their authors and need not follow the licensing terms
-+  * described here, provided that the new terms are clearly indicated in
-+  * all files where they apply.
-+  *
-+  * IN NO EVENT SHALL THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, THE
-+  * UNIVERSITY OF UTAH OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY
-+  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
-+  * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
-+  * EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF
-+  * THE POSSIBILITY OF SUCH DAMAGE.
-+  *
-+  * THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, AND THE UNIVERSITY OF UTAH
-+  * SPECIFICALLY DISCLAIM ANY WARRANTIES,INCLUDING, BUT NOT LIMITED TO,
-+  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-+  * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
-+  * THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE,
-+  * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-+  *
-+  *******************************************************************************/
-+ 
-+ #include "internal.h"
-+ 
-+ /*******************************************************************************
-+  * $Header$
-+  *
-+  * File : vector.cxx
-+  *
-+  * A very simple Vector class.  Allways assumes that memory allocations are
-+  * successful.  Should be made more robust...
-+  *
-+  *******************************************************************************/
-+ 
-+ void* Vector::s_nullPtr = NULL;
-+ 
-+ // -----------------------------------------------------------------------------
-+ // Vector::Vector(size_t allocSize = 8)
-+ //
-+ // Constructor.  Creates a new Vector.
-+ //
-+ // Inputs : initial allocation size (optional)
-+ //
-+ // Output : New Vector object.
-+ //
-+ // Side Effects : None
-+ // -----------------------------------------------------------------------------
-+ 
-+ Vector::Vector(size_t allocSize)
-+     : m_size(allocSize),
-+       m_count(0),
-+       m_data(0)
-+ {
-+     if (m_size) {
-+         m_data = new void*[m_size];
-+         int i;
-+         for (i=0; i<m_size;i++)
-+             m_data[i] = 0;
-+     }
-+ }
-+ 
-+ 
-+ // -----------------------------------------------------------------------------
-+ // Vector::~Vector
-+ //
-+ // Destructor.  Only cleans up the vector, not its contents!
-+ //
-+ // -----------------------------------------------------------------------------
-+ 
-+ 
-+ Vector::~Vector() {
-+     if (m_data) {
-+         delete [] m_data;
-+     }
-+ 
-+     m_data = 0;
-+     m_size = m_count = 0;
-+ }
-+ 
-+ 
-+ 
-+ // -----------------------------------------------------------------------------
-+ // size_t Vector::extend(size_t newSize)
-+ //
-+ // Extends the vector to at least newSize length.  Won't do anything if newSize
-+ // is smaller than the current size of the vector.
-+ //
-+ // Returns the new allocated size.
-+ //
-+ // -----------------------------------------------------------------------------
-+ 
-+ #define GRANULARITY     16
-+ 
-+ size_t Vector::extend(size_t newSize) {
-+ 
-+     if (newSize > m_size) {
-+         newSize = newSize + (GRANULARITY - (newSize % GRANULARITY));
-+ 
-+         void** temp = new void*[newSize];
-+         memcpy(temp, m_data, m_size*sizeof(void*));
-+ 
-+         int i;
-+         for (i=m_size; i<newSize; i++)
-+             temp[i] = 0;
-+ 
-+         delete [] m_data;
-+         m_data = temp;
-+         m_size = newSize;
-+     }
-+     return m_size;
-+ }
-+ 
-+ 
-+ // -----------------------------------------------------------------------------
-+ // Vector::append(void* object)
-+ //
-+ // Appends the object pointer to vector at index m_count.  Increments m_count.
-+ // Returns the new count.
-+ // -----------------------------------------------------------------------------
-+ 
-+ size_t Vector::append(void* object) {
-+     if (m_count >= m_size) {
-+         extend(m_count + 1);
-+     }
-+ 
-+     m_data[m_count] = object;
-+     m_count += 1;
-+ 
-+     return m_count;
-+ }
-+ 
-+ 
-+ // -----------------------------------------------------------------------------
-+ // Vector::operator[] (size_t idx)
-+ //
-+ // Returns a reference to the void pointer at idx.  If idx is beyond the range
-+ // of the vector, returns a reference to s_nullPtr.
-+ //
-+ // -----------------------------------------------------------------------------
-+ 
-+ void*& Vector::operator[] (size_t idx) {
-+     if (idx >= m_size) {
-+         s_nullPtr = 0;
-+         return s_nullPtr;
-+     }
-+ 
-+     return m_data[idx];
-+ }
-+ 
-+ 
-+ /***********************************************************************
-+  *
-+  * -- Revision History
-+  * $Log$
-+  * Revision 1.1  1998/10/03 05:56:03  RD
-+  * *** empty log message ***
-+  *
-+  *
-+  ***********************************************************************/
-+ 
-+ 
-+ 
-+ 
-+ 
-+ 
-*** makefile.msc.old	Mon Jun 23 15:15:32 1997
---- makefile.msc	Fri Aug 28 10:21:58 1998
-***************
-*** 33,50 ****
-  # Normally, you shouldn't have to change anything below this point     #
-  ########################################################################
-  
-  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
-!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
-  
-  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
-! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
-            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
-  
-  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
-  LIBNAME      = ..\libswig.lib
-  INCLUDE  = -I../Include -I$(STD_INC)
-! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS)
-  LD_FLAGS    =  -VERBOSE
-  
-  
-  #
---- 33,50 ----
-  # Normally, you shouldn't have to change anything below this point     #
-  ########################################################################
-  
-  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
-!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
-  
-  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
-! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
-            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
-  
-  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
-  LIBNAME      = ..\libswig.lib
-  INCLUDE  = -I../Include -I$(STD_INC)
-! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS) $(OTHERFLAGS)
-  LD_FLAGS    =  -VERBOSE
-  
-  
-  #
-*** makefile.bc.old	Sun Jan 04 12:49:24 1998
---- makefile.bc	Fri Aug 28 14:42:58 1998
-***************
-*** 34,47 ****
-  ########################################################################
-  
-  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
-            emit.obj newdoc.obj ascii.obj \
-!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj \
-            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
-  
-  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
-            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
-!           sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
-  
-  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
-  LIBNAME      = ..\libswig.lib
-  INCLUDE  = -I../Include -I$(STD_INC)
---- 34,47 ----
-  ########################################################################
-  
-  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
-            emit.obj newdoc.obj ascii.obj \
-!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj \
-            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
-  
-  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
-            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
-!           vector.cxx sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
-  
-  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
-  LIBNAME      = ..\libswig.lib
-  INCLUDE  = -I../Include -I$(STD_INC)
-*** Makefile.in.old	Wed May 28 22:56:56 1997
---- Makefile.in	Fri Aug 28 14:43:36 1998
-***************
-*** 51,63 ****
-  # Normally, you shouldn't have to change anything below this point     #
-  ########################################################################
-  
-  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
-!           html.o latex.o cplus.o lang.o hash.o sstring.o wrapfunc.o getopt.o comment.o \
-            typemap.o naming.o
-  
-  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
-! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
-            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
-  
-  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
-  LIB      = ../libswig.a
---- 51,63 ----
-  # Normally, you shouldn't have to change anything below this point     #
-  ########################################################################
-  
-  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
-!           html.o latex.o cplus.o lang.o hash.o vector.o sstring.o wrapfunc.o getopt.o comment.o \
-            typemap.o naming.o
-  
-  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
-! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
-            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
-  
-  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
-  LIB      = ../libswig.a

utils/wxPython/TODO.txt

@@ -1,43 +0,0 @@
-wxPython TODO List
-------------------
-
-These are the major tasks to be done on wxPython:
-
-1. Get it working for wxGTK.
-
-2. Figure out how to do embedding of wxPython in a wxWindows C++
-   application.
-
-    Actually, now that I think about it it might actually work.  We
-    just need to move some of the wxWindows initialization stuff out
-    of wxpcinit, ensure that __wxStart is not called and that a wxApp
-    is not created.  So this task becomes: Create a test case for
-    embedding wxPython in a C++ app.  Should also create some helper
-    functions for passing window objects into the Python code, etc.
-
-    Test this with M.
-
-
-3. Add significantly to the tests.
-
-4. Derived Python classes should have the ability to call the standard
-   On** methods in the base class.
-
-5. There are some virtual On** and other methods in wxWindows that
-   should end up being callbacks in derived python classes, but they
-   are not called via the standard event system.  Is there any way to
-   hook into these and call Python methods (if they exist in the
-   derived class) without having to derive a specialized C++ class?
-
-6. Add the Doc/View related classes
-
-7. Add the Printing related classes
-
-8. Document the differences (method signatures, new methods to
-   compensate for no overloading, etc.) between wxPython and wxWindows.
-
-9. Create some larger-scale sample application with wxPython to show
-   it can be done and the simplicity that it will provide...  Test
-   distribution with Freeze.
-
-

utils/wxPython/distrib/wxPython.rsp

@@ -1,38 +0,0 @@
-wxPython\*.pyd
-wxPython\*.pyc
-wxPython\*.pyo
-wxPython\*.py
-wxPython\*.txt
-
-wxPython\tests\*.py
-wxPython\tests\bitmaps
-
-
-wxPython\src\*.i
-wxPython\src\*.py
-wxPython\src\*.cpp
-wxPython\src\*.h
-wxPython\src\*.ico
-wxPython\src\*.def
-wxPython\src\*.rc
-wxPython\src\makefile.*
-wxPython\src\Makefile.pre.in
-wxPython\src\Setup.in
-
-wxPython\src\msw\*.cpp
-wxPython\src\msw\*.h
-wxPython\src\msw\*.py
-
-wxPython\src\gtk\*.cpp
-wxPython\src\gtk\*.h
-wxPython\src\gtk\*.py
-
-wxPython\src\motif\*.cpp
-wxPython\src\motif\*.h
-wxPython\src\motif\*.py
-
-wxPython\src\qt\*.cpp
-wxPython\src\qt\*.h
-wxPython\src\qt\*.py
-
-

utils/wxPython/distrib/zipit.bat

@@ -1,8 +0,0 @@
-
-@echo off
-
-rem cd %WXWIN%\utils
-
-zip -@ -r wxPython\wxPython-%1.zip < wxPython\distrib\wxPython.rsp
-
-cd -

utils/wxPython/src/.cvsignore

@@ -1,26 +0,0 @@
-.emacs.desktop
-Makefile
-Makefile.pre
-Setup
-Setup.save
-Setup.save
-config.c
-make.bat
-sedscript
-templates
-transfer.zip
-vc50.pdb
-vc60.pdb
-wxPython.001
-wxPython.dsp
-wxPython.dsw
-wxPython.ncb
-wxPython.opt
-wxc.exp
-wxc.lib
-wxc.res
-wxp.pch
-wxpc.exp
-wxpc.lib
-wxpc.res
-wxpc.res.save

utils/wxPython/src/Makefile.pre.in

@@ -1,389 +0,0 @@
-# Universal Unix Makefile for Python extensions
-# =============================================
-
-# Short Instructions
-# ------------------
-
-# 1. Build and install Python (1.5 or newer).
-# 2. "make -f Makefile.pre.in boot"
-# 3. "make"
-# You should now have a shared library.
-
-# Long Instructions
-# -----------------
-
-# Build *and install* the basic Python 1.5 distribution.  See the
-# Python README for instructions.  (This version of Makefile.pre.in
-# only withs with Python 1.5, alpha 3 or newer.)
-
-# Create a file Setup.in for your extension.  This file follows the
-# format of the Modules/Setup.in file; see the instructions there.
-# For a simple module called "spam" on file "spammodule.c", it can
-# contain a single line:
-#   spam spammodule.c
-# You can build as many modules as you want in the same directory --
-# just have a separate line for each of them in the Setup.in file.
-
-# If you want to build your extension as a shared library, insert a
-# line containing just the string
-#   *shared*
-# at the top of your Setup.in file.
-
-# Note that the build process copies Setup.in to Setup, and then works
-# with Setup.  It doesn't overwrite Setup when Setup.in is changed, so
-# while you're in the process of debugging your Setup.in file, you may
-# want to edit Setup instead, and copy it back to Setup.in later.
-# (All this is done so you can distribute your extension easily and
-# someone else can select the modules they actually want to build by
-# commenting out lines in the Setup file, without editing the
-# original.  Editing Setup is also used to specify nonstandard
-# locations for include or library files.)
-
-# Copy this file (Misc/Makefile.pre.in) to the directory containing
-# your extension.
-
-# Run "make -f Makefile.pre.in boot".  This creates Makefile
-# (producing Makefile.pre and sedscript as intermediate files) and
-# config.c, incorporating the values for sys.prefix, sys.exec_prefix
-# and sys.version from the installed Python binary.  For this to work,
-# the python binary must be on your path.  If this fails, try
-#   make -f Makefile.pre.in Makefile VERSION=1.5 installdir=<prefix>
-# where <prefix> is the prefix used to install Python for installdir
-# (and possibly similar for exec_installdir=<exec_prefix>).
-
-# Note: "make boot" implies "make clobber" -- it assumes that when you
-# bootstrap you may have changed platforms so it removes all previous
-# output files.
-
-# If you are building your extension as a shared library (your
-# Setup.in file starts with *shared*), run "make" or "make sharedmods"
-# to build the shared library files.  If you are building a statically
-# linked Python binary (the only solution of your platform doesn't
-# support shared libraries, and sometimes handy if you want to
-# distribute or install the resulting Python binary), run "make
-# python".
-
-# Note: Each time you edit Makefile.pre.in or Setup, you must run
-# "make Makefile" before running "make".
-
-# Hint: if you want to use VPATH, you can start in an empty
-# subdirectory and say (e.g.):
-#   make -f ../Makefile.pre.in boot srcdir=.. VPATH=..
-
-
-# === Bootstrap variables (edited through "make boot") ===
-
-# The prefix used by "make inclinstall libainstall" of core python
-installdir=	/usr/local
-
-# The exec_prefix used by the same
-exec_installdir=$(installdir)
-
-# Source directory and VPATH in case you want to use VPATH.
-# (You will have to edit these two lines yourself -- there is no
-# automatic support as the Makefile is not generated by
-# config.status.)
-srcdir=		.
-VPATH=		.
-
-# === Variables that you may want to customize (rarely) ===
-
-# (Static) build target
-TARGET=		python
-
-# Installed python binary (used only by boot target)
-PYTHON=		python
-
-# Add more -I and -D options here
-CFLAGS=		$(OPT) -I$(INCLUDEPY) -I$(EXECINCLUDEPY) $(DEFS)
-
-# These two variables can be set in Setup to merge extensions.
-# See example[23].
-BASELIB=
-BASESETUP=
-
-# === Variables set by makesetup ===
-
-MODOBJS=	_MODOBJS_
-MODLIBS=	_MODLIBS_
-
-# === Definitions added by makesetup ===
-
-# === Variables from configure (through sedscript) ===
-
-VERSION=	@VERSION@
-CC=		@CC@
-LINKCC=		@LINKCC@
-SGI_ABI=	@SGI_ABI@
-OPT=		@OPT@
-LDFLAGS=	@LDFLAGS@
-LDLAST=		@LDLAST@
-DEFS=		@DEFS@
-LIBS=		@LIBS@
-LIBM=		@LIBM@
-LIBC=		@LIBC@
-RANLIB=		@RANLIB@
-MACHDEP=	@MACHDEP@
-SO=		@SO@
-LDSHARED=	@LDSHARED@
-CCSHARED=	@CCSHARED@
-LINKFORSHARED=	@LINKFORSHARED@
-#@SET_CCC@
-
-# Install prefix for architecture-independent files
-prefix=		/usr/local
-
-# Install prefix for architecture-dependent files
-exec_prefix=	$(prefix)
-
-# === Fixed definitions ===
-
-# Shell used by make (some versions default to the login shell, which is bad)
-SHELL=		/bin/sh
-
-# Expanded directories
-BINDIR=		$(exec_installdir)/bin
-LIBDIR=		$(exec_prefix)/lib
-MANDIR=		$(installdir)/man
-INCLUDEDIR=	$(installdir)/include
-SCRIPTDIR=	$(prefix)/lib
-
-# Detailed destination directories
-BINLIBDEST=	$(LIBDIR)/python$(VERSION)
-LIBDEST=	$(SCRIPTDIR)/python$(VERSION)
-INCLUDEPY=	$(INCLUDEDIR)/python$(VERSION)
-EXECINCLUDEPY=	$(exec_installdir)/include/python$(VERSION)
-LIBP=		$(exec_installdir)/lib/python$(VERSION)
-DESTSHARED=	$(BINLIBDEST)/site-packages
-
-LIBPL=		$(LIBP)/config
-
-PYTHONLIBS=	$(LIBPL)/libpython$(VERSION).a
-
-MAKESETUP=	$(LIBPL)/makesetup
-MAKEFILE=	$(LIBPL)/Makefile
-CONFIGC=	$(LIBPL)/config.c
-CONFIGCIN=	$(LIBPL)/config.c.in
-SETUP=		$(LIBPL)/Setup
-
-SYSLIBS=	$(LIBM) $(LIBC)
-
-ADDOBJS=	$(LIBPL)/python.o config.o
-
-# Portable install script (configure doesn't always guess right)
-INSTALL=	$(LIBPL)/install-sh -c
-# Shared libraries must be installed with executable mode on some systems;
-# rather than figuring out exactly which, we always give them executable mode.
-# Also, making them read-only seems to be a good idea...
-INSTALL_SHARED=	${INSTALL} -m 555
-
-#---------------------------------------------------
-# Possibly change some definintions for C++
-ifdef MY_LDSHARED
-LDSHARED=$(MY_LDSHARED)
-endif
-ifdef MY_LINKCC
-LINKCC=$(MY_LINKCC)
-endif
-
-
-# === Fixed rules ===
-
-# Default target.  This builds shared libraries only
-default:	sharedmods
-
-# Build everything
-all:		static sharedmods
-
-# Build shared libraries from our extension modules
-sharedmods:	$(SHAREDMODS)
-
-# Build a static Python binary containing our extension modules
-static:		$(TARGET)
-$(TARGET):	$(ADDOBJS) lib.a $(PYTHONLIBS) Makefile $(BASELIB)
-		$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) \
-		 $(ADDOBJS) lib.a $(PYTHONLIBS) \
-		 $(LINKPATH) $(BASELIB) $(MODLIBS) $(LIBS) $(SYSLIBS) \
-		 -o $(TARGET) $(LDLAST)
-
-#------------------------------------------------------------------------
-#------------------------------------------------------------------------
-# This is a default version of the install target for wxPython.  It just
-# redirects to wxInstall below...
-
-install:	wxInstall
-
-#install:	sharedmods
-#		if test ! -d $(DESTSHARED) ; then \
-#			mkdir $(DESTSHARED) ; else true ; fi
-#		-for i in X $(SHAREDMODS); do \
-#			if test $$i != X; \
-#			then $(INSTALL_SHARED) $$i $(DESTSHARED)/$$i; \
-#			fi; \
-#		done
-
-
-# Build the library containing our extension modules
-lib.a:		$(MODOBJS)
-		-rm -f lib.a
-		ar cr lib.a $(MODOBJS)
-		-$(RANLIB) lib.a
-
-# This runs makesetup *twice* to use the BASESETUP definition from Setup
-config.c Makefile:	Makefile.pre Setup $(BASESETUP) $(MAKESETUP)
-		$(MAKESETUP) \
-		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
-		$(MAKE) -f Makefile do-it-again
-
-# Internal target to run makesetup for the second time
-do-it-again:
-		$(MAKESETUP) \
-		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
-
-# Make config.o from the config.c created by makesetup
-config.o:	config.c
-		$(CC) $(CFLAGS) -c config.c
-
-# Setup is copied from Setup.in *only* if it doesn't yet exist
-Setup:
-		cp Setup.in Setup
-
-# Make the intermediate Makefile.pre from Makefile.pre.in
-Makefile.pre: Makefile.pre.in sedscript
-		sed -f sedscript Makefile.pre.in >Makefile.pre
-
-# Shortcuts to make the sed arguments on one line
-P=prefix
-E=exec_prefix
-H=Generated automatically from Makefile.pre.in by sedscript.
-L=LINKFORSHARED
-
-# Make the sed script used to create Makefile.pre from Makefile.pre.in
-sedscript:	$(MAKEFILE)
-	sed -n \
-	 -e '1s/.*/1i\\/p' \
-	 -e '2s%.*%# $H%p' \
-	 -e '/^VERSION=/s/^VERSION=[ 	]*\(.*\)/s%@VERSION[@]%\1%/p' \
-	 -e '/^CC=/s/^CC=[ 	]*\(.*\)/s%@CC[@]%\1%/p' \
-	 -e '/^CCC=/s/^CCC=[ 	]*\(.*\)/s%#@SET_CCC[@]%CCC=\1%/p' \
-	 -e '/^LINKCC=/s/^LINKCC=[ 	]*\(.*\)/s%@LINKCC[@]%\1%/p' \
-	 -e '/^OPT=/s/^OPT=[ 	]*\(.*\)/s%@OPT[@]%\1%/p' \
-	 -e '/^LDFLAGS=/s/^LDFLAGS=[ 	]*\(.*\)/s%@LDFLAGS[@]%\1%/p' \
-	 -e '/^DEFS=/s/^DEFS=[ 	]*\(.*\)/s%@DEFS[@]%\1%/p' \
-	 -e '/^LIBS=/s/^LIBS=[ 	]*\(.*\)/s%@LIBS[@]%\1%/p' \
-	 -e '/^LIBM=/s/^LIBM=[ 	]*\(.*\)/s%@LIBM[@]%\1%/p' \
-	 -e '/^LIBC=/s/^LIBC=[ 	]*\(.*\)/s%@LIBC[@]%\1%/p' \
-	 -e '/^RANLIB=/s/^RANLIB=[ 	]*\(.*\)/s%@RANLIB[@]%\1%/p' \
-	 -e '/^MACHDEP=/s/^MACHDEP=[ 	]*\(.*\)/s%@MACHDEP[@]%\1%/p' \
-	 -e '/^SO=/s/^SO=[ 	]*\(.*\)/s%@SO[@]%\1%/p' \
-	 -e '/^LDSHARED=/s/^LDSHARED=[ 	]*\(.*\)/s%@LDSHARED[@]%\1%/p' \
-	 -e '/^CCSHARED=/s/^CCSHARED=[ 	]*\(.*\)/s%@CCSHARED[@]%\1%/p' \
-	 -e '/^$L=/s/^$L=[ 	]*\(.*\)/s%@$L[@]%\1%/p' \
-	 -e '/^$P=/s/^$P=\(.*\)/s%^$P=.*%$P=\1%/p' \
-	 -e '/^$E=/s/^$E=\(.*\)/s%^$E=.*%$E=\1%/p' \
-	 $(MAKEFILE) >sedscript
-	echo "/^#@SET_CCC@/d" >>sedscript
-	echo "/^installdir=/s%=.*%=	$(installdir)%" >>sedscript
-	echo "/^exec_installdir=/s%=.*%=$(exec_installdir)%" >>sedscript
-	echo "/^srcdir=/s%=.*%=		$(srcdir)%" >>sedscript
-	echo "/^VPATH=/s%=.*%=		$(VPATH)%" >>sedscript
-	echo "/^LINKPATH=/s%=.*%=	$(LINKPATH)%" >>sedscript
-	echo "/^BASELIB=/s%=.*%=	$(BASELIB)%" >>sedscript
-	echo "/^BASESETUP=/s%=.*%=	$(BASESETUP)%" >>sedscript
-
-# Bootstrap target
-boot:	clobber
-	VERSION=`$(PYTHON) -c "import sys; print sys.version[:3]"`; \
-	installdir=`$(PYTHON) -c "import sys; print sys.prefix"`; \
-	exec_installdir=`$(PYTHON) -c "import sys; print sys.exec_prefix"`; \
-	$(MAKE) -f Makefile.pre.in VPATH=$(VPATH) srcdir=$(srcdir) \
-		VERSION=$$VERSION \
-		installdir=$$installdir \
-		exec_installdir=$$exec_installdir \
-		Makefile
-
-# Handy target to remove intermediate files and backups
-clean:
-		-rm -f *.o *~
-
-# Handy target to remove everything that is easily regenerated
-clobber:	clean
-		-rm -f *.a tags TAGS config.c Makefile.pre $(TARGET) sedscript
-		-rm -f *.so *.sl so_locations
-
-
-# Handy target to remove everything you don't want to distribute
-distclean:	clobber
-		-rm -f Makefile Setup
-
-
-
-
-#------------------------------------------------------------------------
-#------------------------------------------------------------------------
-# Custom rules and dependencies added for wxPython
-#
-
-
-SWIGFLAGS=-c++ -shadow -python -dnone -D__WXGTK__
-
-
-PYMODULES = $(GENCODEDIR)/wx.py        $(GENCODEDIR)/events.py    \
-	    $(GENCODEDIR)/windows.py   $(GENCODEDIR)/misc.py      \
-	    $(GENCODEDIR)/gdi.py       $(GENCODEDIR)/mdi.py       \
-	    $(GENCODEDIR)/controls.py  $(GENCODEDIR)/controls2.py \
-            $(GENCODEDIR)/windows2.py  $(GENCODEDIR)/cmndlgs.py   \
-            $(GENCODEDIR)/frames.py    $(GENCODEDIR)/stattool.py   \
-	    $(GENCODEDIR)/utils.py     $(GENCODEDIR)/windows3.py  \
-	    __init__.py
-
-
-# Implicit rules to run SWIG
-$(GENCODEDIR)/%.cpp : %.i
-	swig $(SWIGFLAGS) -c -o $@ $<
-
-$(GENCODEDIR)/%.py : %.i
-	swig $(SWIGFLAGS) -c -o $@ $<
-
-
-# This one must leave out the -c flag so we define the whole rule
-$(GENCODEDIR)/wx.cpp $(GENCODEDIR)/wx.py : wx.i my_typemaps.i _defs.i _extras.py
-	swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
-
-
-# define some dependencies
-$(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py   : windows.i    my_typemaps.i _defs.i
-$(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py  : windows2.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py  : windows3.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py    : events.i     my_typemaps.i _defs.i
-$(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py      : misc.i       my_typemaps.i _defs.i
-$(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py       : gdi.i        my_typemaps.i _defs.i
-$(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py       : mdi.i        my_typemaps.i _defs.i
-$(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py  : controls.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i  my_typemaps.i _defs.i
-$(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py   : cmndlgs.i    my_typemaps.i _defs.i
-$(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py    : frames.i     my_typemaps.i _defs.i
-$(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py  : stattool.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/utils.cpp     $(GENCODEDIR)/utils.py     : utils.i      my_typemaps.i _defs.i
-
-$(GENCODEDIR)/helpers.cpp:
-	ln -s `pwd`/helpers.cpp $@
-
-
-wxInstall :	sharedmods $(PYMODULES)
-	if test ! -d $(TARGETDIR) ; then \
-		mkdir $(TARGETDIR) ; else true ; fi
-	if [ "$(SHAREDMODS)" != "" ]; then \
-		 chmod 755 $(SHAREDMODS); \
-		 cp $(SHAREDMODS) $(TARGETDIR); fi
-	-for i in $(PYMODULES); do \
-		cp $$i $(TARGETDIR); \
-	done
-	python $(LIBDEST)/compileall.py -l $(TARGETDIR)
-	python -O $(LIBDEST)/compileall.py -l $(TARGETDIR)
-
-
-lib : libwxPython.a
-
-libwxPython.a : lib.a
-	cp $< $@

utils/wxPython/src/Setup.in

@@ -1,44 +0,0 @@
-# This file gives the details of what is needed to build this extension
-# module so the Makefile can be created.
-
-###
-### This file should be created by configure.  Currently it is tweaked by hand.
-###
-
-*shared*
-
-CCC=c++
-WXWIN=../../..
-GENCODEDIR=gtk
-srcdir=$(GENCODEDIR)
-
-# Depending on how your Python was built, you may have to set this
-# value to use the C++ driver to link with instead of the default
-# C driver.  For example:
-MY_LDSHARED=$(CCC) -shared
-
-# Same as above, but for statically linking Python and wxPython together,
-# in other words, if you comment out the *shared* above.  If this is the
-# case then you should ensure that the main() function is Python's, not
-# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
-# to force this...
-MY_LINKCC=$(CCC)
-
-
-## Pick one of these, or set your own.  This is where the
-## wxPython module should be installed.  It should be a
-## subdirectory named wxPython.
-TARGETDIR=..
-#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
-
-
-wxc	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
-	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
-	frames.cpp stattool.cpp utils.cpp windows3.cpp \
-	# CFLAGS
-	-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
-	-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
-	#-D__WXDEBUG__ \
-	# LFLAGS
-	-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
-	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11

utils/wxPython/src/Setup.in.linux

@@ -1,44 +0,0 @@
-# This file gives the details of what is needed to build this extension
-# module so the Makefile can be created.
-
-###
-### This file should be created by configure.  Currently it is tweaked by hand.
-###
-
-*shared*
-
-CCC=c++
-WXWIN=../../..
-GENCODEDIR=gtk
-srcdir=$(GENCODEDIR)
-
-# Depending on how your Python was built, you may have to set this
-# value to use the C++ driver to link with instead of the default
-# C driver.  For example:
-MY_LDSHARED=$(CCC) -shared
-
-# Same as above, but for statically linking Python and wxPython together,
-# in other words, if you comment out the *shared* above.  If this is the
-# case then you should ensure that the main() function is Python's, not
-# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
-# to force this...
-MY_LINKCC=$(CCC)
-
-
-## Pick one of these, or set your own.  This is where the
-## wxPython module should be installed.  It should be a
-## subdirectory named wxPython.
-TARGETDIR=..
-#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
-
-
-wxc	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
-	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
-	frames.cpp stattool.cpp utils.cpp windows3.cpp \
-	# CFLAGS
-	-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
-	-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
-	#-D__WXDEBUG__ \
-	# LFLAGS
-	-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
-	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11

utils/wxPython/src/Setup.in.solaris

@@ -1,45 +0,0 @@
-# This file gives the details of what is needed to build this extension
-# module so the Makefile can be created.
-
-###
-### This file should be created by configure.  Currently it is tweaked by hand.
-###
-
-#*shared*
-
-CCC=c++
-WXWIN=../../..
-GENCODEDIR=gtk
-srcdir=$(GENCODEDIR)
-
-# Depending on how your Python was built, you may have to set this
-# value to use the C++ driver to link with instead of the default
-# C driver.  For example:
-#MY_LDSHARED=$(CCC) -shared
-
-# Same as above, but for statically linking Python and wxPython together,
-# in other words, if you comment out the *shared* above.  If this is the
-# case then you should ensure that the main() function is Python's, not
-# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
-# to force this...
-MY_LINKCC=$(CCC)
-
-
-## Pick one of these, or set your own.  This is where the
-## wxPython module should be installed.  It should be a
-## subdirectory named wxPython.
-TARGETDIR=..
-#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
-
-
-wxc 	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
-	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
-	frames.cpp stattool.cpp utils.cpp windows3.cpp \
-	# CFLAGS
-	-I. -I$(WXWIN)/include -I/usr/local/lib/glib/include -I$(WXWIN)/src \
-	-I/usr/X/include -DSWIG_GLOBAL -D__WXGTK__ \
-	#-D__WXDEBUG__ \
-	# LFLAGS
-	-L$(WXWIN)/lib/solaris2.6 -L/usr/X/lib \
-	-L/usr/local/lib/gcc-lib/sparc-sun-solaris2.6/2.8.1 \
-	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11 -lstdc++ -lgcc

utils/wxPython/src/__init__.py

@@ -1,43 +0,0 @@
-#----------------------------------------------------------------------------
-# Name:         __init__.py
-# Purpose:      The presence of this file turns this directory into a
-#               Python package.
-#
-# Author:       Robin Dunn
-#
-# Created:      8/8/98
-# RCS-ID:       $Id$
-# Copyright:    (c) 1998 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-
-#----------------------------------------------------------------------------
-#
-# $Log$
-# Revision 1.3  1998/12/15 20:41:12  RD
-# Changed the import semantics from "from wxPython import *" to "from
-# wxPython.wx import *"  This is for people who are worried about
-# namespace pollution, they can use "from wxPython import wx" and then
-# prefix all the wxPython identifiers with "wx."
-#
-# Added wxTaskbarIcon for wxMSW.
-#
-# Made the events work for wxGrid.
-#
-# Added wxConfig.
-#
-# Added wxMiniFrame for wxGTK, (untested.)
-#
-# Changed many of the args and return values that were pointers to gdi
-# objects to references to reflect changes in the wxWindows API.
-#
-# Other assorted fixes and additions.
-#
-# Revision 1.2  1998/10/07 07:34:32  RD
-# Version 0.4.1 for wxGTK
-#
-# Revision 1.1  1998/08/09 08:25:49  RD
-# Initial version
-#
-#

utils/wxPython/src/_defs.i

@@ -1,763 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        _defs.i
-// Purpose:     Definitions and stuff
-//
-// Author:      Robin Dunn
-//
-// Created:     6/24/97
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-
-//---------------------------------------------------------------------------
-// Forward declares...
-
-class wxPyApp;
-class wxEvtHandler;
-class wxWindow;
-class wxFrame;
-class wxMiniFrame;
-class wxPanel;
-class wxDialog;
-class wxMenu;
-class wxPyMenu;
-class wxMenuBar;
-class wxMenuItem;
-class wxEvent;
-class wxSizeEvent;
-class wxCloseEvent;
-class wxCommandEvent;
-class wxScrollEvent;
-class wxMouseEvent;
-class wxKeyEvent;
-class wxMoveEvent;
-class wxPaintEvent;
-class wxEraseEvent;
-class wxFocusEvent;
-class wxActivateEvent;
-class wxInitDialogEvent;
-class wxMenuEvent;
-class wxShowEvent;
-class wxIconizeEvent;
-class wxMaximizeEvent;
-class wxJoystickEvent;
-class wxDropFilesEvent;
-class wxIdleEvent;
-class wxUpdateUIEvent;
-class wxSysColourChangedEvent;
-class wxSize;
-class wxRealPoint;
-class wxPoint;
-class wxRect;
-class wxBitmap;
-class wxMask;
-class wxIcon;
-class wxCursor;
-class wxFont;
-class wxColour;
-class wxPen;
-class wxBrush;
-class wxDC;
-class wxMemoryDC;
-class wxScreenDC;
-class wxClientDC;
-class wxPaintDC;
-class wxPostScriptDC;
-class wxPrinterDC;
-class wxMetaFileDC;
-class wxMDIParentFrame;
-class wxMDIChildFrame;
-class wxMDIClientWindow;
-class wxControl;
-class wxButton;
-class wxBitmapButton;
-class wxCheckBox;
-class wxChoice;
-class wxComboBox;
-class wxGauge;
-class wxStaticBox;
-class wxStaticText;
-class wxListBox;
-class wxTextCtrl;
-class wxScrollBar;
-class wxSpinButton;
-class wxStaticBitmap;
-class wxRadioBox;
-class wxRadioButton;
-class wxSlider;
-
-class wxPyTimer;
-class wxIndividualLayoutConstraint;
-class wxLayoutConstraints;
-class wxToolBar;
-class wxStatusBar;
-
-//---------------------------------------------------------------------------
-
-// some definitions for SWIG only
-typedef unsigned char   byte;
-typedef short int       WXTYPE;
-typedef int             wxWindowID;
-typedef unsigned int    uint;
-typedef signed   int    EBool;
-
-
-//---------------------------------------------------------------------------
-
-// General numeric #define's and etc.  Making them all enums makes SWIG use the
-// real macro when making the Python Int
-
-enum {
-    wxMAJOR_VERSION,
-    wxMINOR_VERSION,
-    wxRELEASE_NUMBER,
-
-    wxNOT_FOUND,
-
-    wxVSCROLL,
-    wxHSCROLL,
-    wxCAPTION,
-    wxDOUBLE_BORDER,
-    wxSUNKEN_BORDER,
-    wxRAISED_BORDER,
-    wxBORDER,
-    wxSIMPLE_BORDER,
-    wxSTATIC_BORDER,
-    wxTRANSPARENT_WINDOW,
-    wxNO_BORDER,
-    wxUSER_COLOURS,
-    wxNO_3D,
-//wxOVERRIDE_KEY_TRANSLATIONS,
-    wxTAB_TRAVERSAL,
-    wxHORIZONTAL,
-    wxVERTICAL,
-    wxBOTH,
-    wxCENTER_FRAME,
-    wxSTAY_ON_TOP,
-    wxICONIZE,
-    wxMINIMIZE,
-    wxMAXIMIZE,
-    wxTHICK_FRAME,
-    wxSYSTEM_MENU,
-    wxMINIMIZE_BOX,
-    wxMAXIMIZE_BOX,
-    wxTINY_CAPTION_HORIZ,
-    wxTINY_CAPTION_VERT,
-    wxRESIZE_BOX,
-    wxRESIZE_BORDER,
-    wxDIALOG_MODAL,
-    wxDIALOG_MODELESS,
-    wxDEFAULT_FRAME_STYLE,
-    wxDEFAULT_DIALOG_STYLE,
-
-    wxFRAME_TOOL_WINDOW,
-    wxCLIP_CHILDREN,
-
-    wxRETAINED,
-    wxBACKINGSTORE,
-    wxTB_3DBUTTONS,
-    wxTB_HORIZONTAL,
-    wxTB_VERTICAL,
-    wxTB_FLAT,
-    wxCOLOURED,
-    wxFIXED_LENGTH,
-    wxALIGN_LEFT,
-    wxALIGN_CENTER,
-    wxALIGN_CENTRE,
-    wxALIGN_RIGHT,
-    wxLB_NEEDED_SB,
-    wxLB_ALWAYS_SB,
-    wxLB_SORT,
-    wxLB_SINGLE,
-    wxLB_MULTIPLE,
-    wxLB_EXTENDED,
-    wxLB_OWNERDRAW,
-    wxLB_HSCROLL,
-    wxPROCESS_ENTER,
-    wxPASSWORD,
-    wxTE_PROCESS_ENTER,
-    wxTE_PASSWORD,
-    wxTE_READONLY,
-    wxTE_MULTILINE,
-    wxCB_SIMPLE,
-    wxCB_DROPDOWN,
-    wxCB_SORT,
-    wxCB_READONLY,
-    wxRA_HORIZONTAL,
-    wxRA_VERTICAL,
-    wxRB_GROUP,
-    wxGA_PROGRESSBAR,
-    wxGA_HORIZONTAL,
-    wxGA_VERTICAL,
-    wxSL_HORIZONTAL,
-    wxSL_VERTICAL,
-    wxSL_AUTOTICKS,
-    wxSL_LABELS,
-    wxSL_LEFT,
-    wxSL_TOP,
-    wxSL_RIGHT,
-    wxSL_BOTTOM,
-    wxSL_BOTH,
-    wxSL_SELRANGE,
-    wxSB_HORIZONTAL,
-    wxSB_VERTICAL,
-    wxBU_AUTODRAW,
-    wxBU_NOAUTODRAW,
-    wxTR_HAS_BUTTONS,
-    wxTR_EDIT_LABELS,
-    wxTR_LINES_AT_ROOT,
-    wxLC_ICON,
-    wxLC_SMALL_ICON,
-    wxLC_LIST,
-    wxLC_REPORT,
-    wxLC_ALIGN_TOP,
-    wxLC_ALIGN_LEFT,
-    wxLC_AUTOARRANGE,
-    wxLC_USER_TEXT,
-    wxLC_EDIT_LABELS,
-    wxLC_NO_HEADER,
-    wxLC_NO_SORT_HEADER,
-    wxLC_SINGLE_SEL,
-    wxLC_SORT_ASCENDING,
-    wxLC_SORT_DESCENDING,
-    wxLC_MASK_TYPE,
-    wxLC_MASK_ALIGN,
-    wxLC_MASK_SORT,
-    wxSP_VERTICAL,
-    wxSP_HORIZONTAL,
-    wxSP_ARROW_KEYS,
-    wxSP_WRAP,
-    wxSP_NOBORDER,
-    wxSP_3D,
-    wxSP_BORDER,
-    wxTAB_MULTILINE,
-    wxTAB_RIGHTJUSTIFY,
-    wxTAB_FIXEDWIDTH,
-    wxTAB_OWNERDRAW,
-//    wxSB_SIZEGRIP,
-    wxFLOOD_SURFACE,
-    wxFLOOD_BORDER,
-    wxODDEVEN_RULE,
-    wxWINDING_RULE,
-    wxTOOL_TOP,
-    wxTOOL_BOTTOM,
-    wxTOOL_LEFT,
-    wxTOOL_RIGHT,
-    wxOK,
-    wxYES_NO,
-    wxCANCEL,
-    wxYES,
-    wxNO,
-    wxICON_EXCLAMATION,
-    wxICON_HAND,
-    wxICON_QUESTION,
-    wxICON_INFORMATION,
-    wxICON_STOP,
-    wxICON_ASTERISK,
-    wxICON_MASK,
-    wxCENTRE,
-    wxCENTER,
-    wxSIZE_AUTO_WIDTH,
-    wxSIZE_AUTO_HEIGHT,
-    wxSIZE_AUTO,
-    wxSIZE_USE_EXISTING,
-    wxSIZE_ALLOW_MINUS_ONE,
-#ifndef __WXGTK__
-    wxDF_TEXT,
-    wxDF_BITMAP,
-    wxDF_METAFILE,
-    wxDF_DIB,
-    wxDF_OEMTEXT,
-    wxDF_FILENAME,
-#endif
-    wxPORTRAIT,
-    wxLANDSCAPE,
-    wxID_OPEN,
-    wxID_CLOSE,
-    wxID_NEW,
-    wxID_SAVE,
-    wxID_SAVEAS,
-    wxID_REVERT,
-    wxID_EXIT,
-    wxID_UNDO,
-    wxID_REDO,
-    wxID_HELP,
-    wxID_PRINT,
-    wxID_PRINT_SETUP,
-    wxID_PREVIEW,
-    wxID_ABOUT,
-    wxID_HELP_CONTENTS,
-    wxID_HELP_COMMANDS,
-    wxID_HELP_PROCEDURES,
-    wxID_HELP_CONTEXT,
-    wxID_CUT,
-    wxID_COPY,
-    wxID_PASTE,
-    wxID_CLEAR,
-    wxID_FIND,
-    wxID_FILE1,
-    wxID_FILE2,
-    wxID_FILE3,
-    wxID_FILE4,
-    wxID_FILE5,
-    wxID_FILE6,
-    wxID_FILE7,
-    wxID_FILE8,
-    wxID_FILE9,
-    wxID_OK,
-    wxID_CANCEL,
-    wxID_APPLY,
-    wxID_YES,
-    wxID_NO,
-    wxBITMAP_TYPE_BMP,
-    wxBITMAP_TYPE_BMP_RESOURCE,
-    wxBITMAP_TYPE_ICO,
-    wxBITMAP_TYPE_ICO_RESOURCE,
-    wxBITMAP_TYPE_CUR,
-    wxBITMAP_TYPE_CUR_RESOURCE,
-    wxBITMAP_TYPE_XBM,
-    wxBITMAP_TYPE_XBM_DATA,
-    wxBITMAP_TYPE_XPM,
-    wxBITMAP_TYPE_XPM_DATA,
-    wxBITMAP_TYPE_TIF,
-    wxBITMAP_TYPE_TIF_RESOURCE,
-    wxBITMAP_TYPE_GIF,
-    wxBITMAP_TYPE_GIF_RESOURCE,
-    wxBITMAP_TYPE_PNG,
-    wxBITMAP_TYPE_PNG_RESOURCE,
-    wxBITMAP_TYPE_ANY,
-    wxBITMAP_TYPE_RESOURCE,
-
-    wxOPEN,
-    wxSAVE,
-    wxHIDE_READONLY,
-    wxOVERWRITE_PROMPT,
-
-    wxACCEL_ALT,
-    wxACCEL_CTRL,
-    wxACCEL_SHIFT,
-};
-
-
-/// Standard error codes
-enum  ErrCode
-{
-  ERR_PARAM = (-4000),
-  ERR_NODATA,
-  ERR_CANCEL,
-  ERR_SUCCESS = 0
-};
-
-
-enum {
-  wxDEFAULT ,
-  wxDECORATIVE,
-  wxROMAN,
-  wxSCRIPT,
-  wxSWISS,
-  wxMODERN,
-  wxTELETYPE,
-  wxVARIABLE,
-  wxFIXED,
-  wxNORMAL,
-  wxLIGHT,
-  wxBOLD,
-  wxITALIC,
-  wxSLANT,
-  wxSOLID,
-  wxDOT,
-  wxLONG_DASH,
-  wxSHORT_DASH,
-  wxDOT_DASH,
-  wxUSER_DASH,
-  wxTRANSPARENT,
-  wxSTIPPLE,
-  wxBDIAGONAL_HATCH,
-  wxCROSSDIAG_HATCH,
-  wxFDIAGONAL_HATCH,
-  wxCROSS_HATCH,
-  wxHORIZONTAL_HATCH,
-  wxVERTICAL_HATCH,
-  wxJOIN_BEVEL,
-  wxJOIN_MITER,
-  wxJOIN_ROUND,
-  wxCAP_ROUND,
-  wxCAP_PROJECTING,
-  wxCAP_BUTT
-};
-
-typedef enum {
-  wxCLEAR,      // 0
-  wxXOR,        // src XOR dst
-  wxINVERT,     // NOT dst
-  wxOR_REVERSE, // src OR (NOT dst)
-  wxAND_REVERSE,// src AND (NOT dst)
-  wxCOPY,       // src
-  wxAND,        // src AND dst
-  wxAND_INVERT, // (NOT src) AND dst
-  wxNO_OP,      // dst
-  wxNOR,        // (NOT src) AND (NOT dst)
-  wxEQUIV,      // (NOT src) XOR dst
-  wxSRC_INVERT, // (NOT src)
-  wxOR_INVERT,  // (NOT src) OR dst
-  wxNAND,       // (NOT src) OR (NOT dst)
-  wxOR,         // src OR dst
-  wxSET,        // 1
-  wxSRC_OR,     // source _bitmap_ OR destination
-  wxSRC_AND     // source _bitmap_ AND destination
-} form_ops_t;
-
-enum _Virtual_keycodes {
- WXK_BACK    =   8,
- WXK_TAB     =   9,
- WXK_RETURN  =	13,
- WXK_ESCAPE  =	27,
- WXK_SPACE   =	32,
- WXK_DELETE  = 127,
-
- WXK_START   = 300,
- WXK_LBUTTON,
- WXK_RBUTTON,
- WXK_CANCEL,
- WXK_MBUTTON,
- WXK_CLEAR,
- WXK_SHIFT,
- WXK_CONTROL,
- WXK_MENU,
- WXK_PAUSE,
- WXK_CAPITAL,
- WXK_PRIOR,  // Page up
- WXK_NEXT,   // Page down
- WXK_END,
- WXK_HOME,
- WXK_LEFT,
- WXK_UP,
- WXK_RIGHT,
- WXK_DOWN,
- WXK_SELECT,
- WXK_PRINT,
- WXK_EXECUTE,
- WXK_SNAPSHOT,
- WXK_INSERT,
- WXK_HELP,
- WXK_NUMPAD0,
- WXK_NUMPAD1,
- WXK_NUMPAD2,
- WXK_NUMPAD3,
- WXK_NUMPAD4,
- WXK_NUMPAD5,
- WXK_NUMPAD6,
- WXK_NUMPAD7,
- WXK_NUMPAD8,
- WXK_NUMPAD9,
- WXK_MULTIPLY,
- WXK_ADD,
- WXK_SEPARATOR,
- WXK_SUBTRACT,
- WXK_DECIMAL,
- WXK_DIVIDE,
- WXK_F1,
- WXK_F2,
- WXK_F3,
- WXK_F4,
- WXK_F5,
- WXK_F6,
- WXK_F7,
- WXK_F8,
- WXK_F9,
- WXK_F10,
- WXK_F11,
- WXK_F12,
- WXK_F13,
- WXK_F14,
- WXK_F15,
- WXK_F16,
- WXK_F17,
- WXK_F18,
- WXK_F19,
- WXK_F20,
- WXK_F21,
- WXK_F22,
- WXK_F23,
- WXK_F24,
- WXK_NUMLOCK,
- WXK_SCROLL,
- WXK_PAGEUP,
- WXK_PAGEDOWN
-};
-
-typedef enum {
- wxCURSOR_NONE = 0,
- wxCURSOR_ARROW =  1,
- wxCURSOR_BULLSEYE,
- wxCURSOR_CHAR,
- wxCURSOR_CROSS,
- wxCURSOR_HAND,
- wxCURSOR_IBEAM,
- wxCURSOR_LEFT_BUTTON,
- wxCURSOR_MAGNIFIER,
- wxCURSOR_MIDDLE_BUTTON,
- wxCURSOR_NO_ENTRY,
- wxCURSOR_PAINT_BRUSH,
- wxCURSOR_PENCIL,
- wxCURSOR_POINT_LEFT,
- wxCURSOR_POINT_RIGHT,
- wxCURSOR_QUESTION_ARROW,
- wxCURSOR_RIGHT_BUTTON,
- wxCURSOR_SIZENESW,
- wxCURSOR_SIZENS,
- wxCURSOR_SIZENWSE,
- wxCURSOR_SIZEWE,
- wxCURSOR_SIZING,
- wxCURSOR_SPRAYCAN,
- wxCURSOR_WAIT,
- wxCURSOR_WATCH,
- wxCURSOR_BLANK
-//  #ifndef __WXMSW__
-//    /* Not yet implemented for Windows */
-//    , wxCURSOR_CROSS_REVERSE,
-//    wxCURSOR_DOUBLE_ARROW,
-//    wxCURSOR_BASED_ARROW_UP,
-//    wxCURSOR_BASED_ARROW_DOWN
-//  #endif
-} _standard_cursors_t;
-
-
-#define FALSE 0
-#define false 0
-#define TRUE 1
-#define true 1
-
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-/*
- * Event types
- *
- */
-enum wxEventType {
- wxEVT_NULL = 0,
- wxEVT_FIRST = 10000,
-
- // New names
- wxEVT_COMMAND_BUTTON_CLICKED,
- wxEVT_COMMAND_CHECKBOX_CLICKED,
- wxEVT_COMMAND_CHOICE_SELECTED,
- wxEVT_COMMAND_LISTBOX_SELECTED,
- wxEVT_COMMAND_LISTBOX_DOUBLECLICKED,
- wxEVT_COMMAND_CHECKLISTBOX_TOGGLED,
- wxEVT_COMMAND_TEXT_UPDATED,
- wxEVT_COMMAND_TEXT_ENTER,
- wxEVT_COMMAND_MENU_SELECTED,
- wxEVT_COMMAND_SLIDER_UPDATED,
- wxEVT_COMMAND_RADIOBOX_SELECTED,
- wxEVT_COMMAND_RADIOBUTTON_SELECTED,
-// wxEVT_COMMAND_SCROLLBAR_UPDATED is now obsolete since we use wxEVT_SCROLL... events
- wxEVT_COMMAND_SCROLLBAR_UPDATED,
- wxEVT_COMMAND_VLBOX_SELECTED,
- wxEVT_COMMAND_COMBOBOX_SELECTED,
- wxEVT_COMMAND_TOOL_CLICKED,
- wxEVT_COMMAND_TOOL_RCLICKED,
- wxEVT_COMMAND_TOOL_ENTER,
- wxEVT_SET_FOCUS,
- wxEVT_KILL_FOCUS,
-
-/* Mouse event types */
- wxEVT_LEFT_DOWN,
- wxEVT_LEFT_UP,
- wxEVT_MIDDLE_DOWN,
- wxEVT_MIDDLE_UP,
- wxEVT_RIGHT_DOWN,
- wxEVT_RIGHT_UP,
- wxEVT_MOTION,
- wxEVT_ENTER_WINDOW,
- wxEVT_LEAVE_WINDOW,
- wxEVT_LEFT_DCLICK,
- wxEVT_MIDDLE_DCLICK,
- wxEVT_RIGHT_DCLICK,
-
- // Non-client mouse events
- wxEVT_NC_LEFT_DOWN = wxEVT_FIRST + 100,
- wxEVT_NC_LEFT_UP,
- wxEVT_NC_MIDDLE_DOWN,
- wxEVT_NC_MIDDLE_UP,
- wxEVT_NC_RIGHT_DOWN,
- wxEVT_NC_RIGHT_UP,
- wxEVT_NC_MOTION,
- wxEVT_NC_ENTER_WINDOW,
- wxEVT_NC_LEAVE_WINDOW,
- wxEVT_NC_LEFT_DCLICK,
- wxEVT_NC_MIDDLE_DCLICK,
- wxEVT_NC_RIGHT_DCLICK,
-
-/* Character input event type  */
- wxEVT_CHAR,
-
- /*
-  * Scrollbar event identifiers
-  */
- wxEVT_SCROLL_TOP,
- wxEVT_SCROLL_BOTTOM,
- wxEVT_SCROLL_LINEUP,
- wxEVT_SCROLL_LINEDOWN,
- wxEVT_SCROLL_PAGEUP,
- wxEVT_SCROLL_PAGEDOWN,
- wxEVT_SCROLL_THUMBTRACK,
-
- wxEVT_SIZE = wxEVT_FIRST + 200,
- wxEVT_MOVE,
- wxEVT_CLOSE_WINDOW,
- wxEVT_END_SESSION,
- wxEVT_QUERY_END_SESSION,
- wxEVT_ACTIVATE_APP,
- wxEVT_POWER,
- wxEVT_CHAR_HOOK,
- wxEVT_KEY_UP,
- wxEVT_ACTIVATE,
- wxEVT_CREATE,
- wxEVT_DESTROY,
- wxEVT_SHOW,
- wxEVT_ICONIZE,
- wxEVT_MAXIMIZE,
- wxEVT_MOUSE_CAPTURE_CHANGED,
- wxEVT_PAINT,
- wxEVT_ERASE_BACKGROUND,
- wxEVT_NC_PAINT,
- wxEVT_PAINT_ICON,
- wxEVT_MENU_CHAR,
- wxEVT_MENU_INIT,
- wxEVT_MENU_HIGHLIGHT,
- wxEVT_POPUP_MENU_INIT,
- wxEVT_CONTEXT_MENU,
- wxEVT_SYS_COLOUR_CHANGED,
- wxEVT_SETTING_CHANGED,
- wxEVT_QUERY_NEW_PALETTE,
- wxEVT_PALETTE_CHANGED,
- wxEVT_JOY_BUTTON_DOWN,
- wxEVT_JOY_BUTTON_UP,
- wxEVT_JOY_MOVE,
- wxEVT_JOY_ZMOVE,
- wxEVT_DROP_FILES,
- wxEVT_DRAW_ITEM,
- wxEVT_MEASURE_ITEM,
- wxEVT_COMPARE_ITEM,
- wxEVT_INIT_DIALOG,
- wxEVT_IDLE,
- wxEVT_UPDATE_UI,
-
- /* Generic command events */
- // Note: a click is a higher-level event
- // than button down/up
- wxEVT_COMMAND_LEFT_CLICK,
- wxEVT_COMMAND_LEFT_DCLICK,
- wxEVT_COMMAND_RIGHT_CLICK,
- wxEVT_COMMAND_RIGHT_DCLICK,
- wxEVT_COMMAND_SET_FOCUS,
- wxEVT_COMMAND_KILL_FOCUS,
- wxEVT_COMMAND_ENTER,
-
- /* Tree control event types */
- wxEVT_COMMAND_TREE_BEGIN_DRAG,
- wxEVT_COMMAND_TREE_BEGIN_RDRAG,
- wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT,
- wxEVT_COMMAND_TREE_END_LABEL_EDIT,
- wxEVT_COMMAND_TREE_DELETE_ITEM,
- wxEVT_COMMAND_TREE_GET_INFO,
- wxEVT_COMMAND_TREE_SET_INFO,
- wxEVT_COMMAND_TREE_ITEM_EXPANDED,
- wxEVT_COMMAND_TREE_ITEM_EXPANDING,
- wxEVT_COMMAND_TREE_ITEM_COLLAPSED,
- wxEVT_COMMAND_TREE_ITEM_COLLAPSING,
- wxEVT_COMMAND_TREE_SEL_CHANGED,
- wxEVT_COMMAND_TREE_SEL_CHANGING,
- wxEVT_COMMAND_TREE_KEY_DOWN,
-
- /* List control event types */
- wxEVT_COMMAND_LIST_BEGIN_DRAG,
- wxEVT_COMMAND_LIST_BEGIN_RDRAG,
- wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT,
- wxEVT_COMMAND_LIST_END_LABEL_EDIT,
- wxEVT_COMMAND_LIST_DELETE_ITEM,
- wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS,
- wxEVT_COMMAND_LIST_GET_INFO,
- wxEVT_COMMAND_LIST_SET_INFO,
- wxEVT_COMMAND_LIST_ITEM_SELECTED,
- wxEVT_COMMAND_LIST_ITEM_DESELECTED,
- wxEVT_COMMAND_LIST_KEY_DOWN,
- wxEVT_COMMAND_LIST_INSERT_ITEM,
- wxEVT_COMMAND_LIST_COL_CLICK,
-
- /* Tab and notebook control event types */
- wxEVT_COMMAND_TAB_SEL_CHANGED,
- wxEVT_COMMAND_TAB_SEL_CHANGING,
- wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
- wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
-
-};
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.10  1999/01/30 07:30:08  RD
-// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-//
-// Various cleanup, tweaks, minor additions, etc. to maintain
-// compatibility with the current wxWindows.
-//
-// Revision 1.9  1998/12/15 20:41:13  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.8  1998/11/15 23:03:42  RD
-// Removing some ifdef's for wxGTK
-//
-// Revision 1.7  1998/11/11 03:12:24  RD
-//
-// Additions for wxTreeCtrl
-//
-// Revision 1.6  1998/10/20 06:43:53  RD
-// New wxTreeCtrl wrappers (untested)
-// some changes in helpers
-// etc.
-//
-// Revision 1.5  1998/10/02 06:40:32  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.4  1998/08/18 19:48:11  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.3  1998/08/14 23:36:33  RD
-// Beginings of wxGTK compatibility
-//
-// Revision 1.2  1998/08/14 03:16:35  RD
-// removed some definitions that got removed from defs.h
-//
-// Revision 1.1  1998/08/09 08:25:49  RD
-// Initial version
-//
-//

utils/wxPython/src/_extras.py

@@ -1,662 +0,0 @@
-#----------------------------------------------------------------------------
-# Name:         _extra.py
-# Purpose:	This file is appended to the shadow class file generated
-#               by SWIG.  We add some unSWIGable things here.
-#
-# Author:       Robin Dunn
-#
-# Created:      6/30/97
-# RCS-ID:       $Id$
-# Copyright:    (c) 1998 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-import sys
-
-#----------------------------------------------------------------------
-# This gives this module's dictionary to the C++ extension code...
-
-_wxSetDictionary(vars())
-
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-# Helper function to link python methods to wxWindows virtual
-# functions by name.
-
-def _checkForCallback(obj, name, event, theID=-1):
-    try:    cb = getattr(obj, name)
-    except: pass
-    else:   obj.Connect(theID, -1, event, cb)
-
-def _StdWindowCallbacks(win):
-    _checkForCallback(win, "OnChar",               wxEVT_CHAR)
-    _checkForCallback(win, "OnSize",               wxEVT_SIZE)
-    _checkForCallback(win, "OnEraseBackground",    wxEVT_ERASE_BACKGROUND)
-    _checkForCallback(win, "OnSysColourChanged",   wxEVT_SYS_COLOUR_CHANGED)
-    _checkForCallback(win, "OnInitDialog",         wxEVT_INIT_DIALOG)
-    _checkForCallback(win, "OnIdle",               wxEVT_IDLE)
-    _checkForCallback(win, "OnPaint",              wxEVT_PAINT)
-
-def _StdFrameCallbacks(win):
-    _StdWindowCallbacks(win)
-    _checkForCallback(win, "OnActivate",           wxEVT_ACTIVATE)
-    _checkForCallback(win, "OnMenuHighlight",      wxEVT_MENU_HIGHLIGHT)
-    _checkForCallback(win, "OnCloseWindow",        wxEVT_CLOSE_WINDOW)
-
-
-def _StdDialogCallbacks(win):
-    _StdWindowCallbacks(win)
-    _checkForCallback(win, "OnOk",     wxEVT_COMMAND_BUTTON_CLICKED,   wxID_OK)
-    _checkForCallback(win, "OnApply",  wxEVT_COMMAND_BUTTON_CLICKED,   wxID_APPLY)
-    _checkForCallback(win, "OnCancel", wxEVT_COMMAND_BUTTON_CLICKED,   wxID_CANCEL)
-    _checkForCallback(win, "OnCloseWindow", wxEVT_CLOSE_WINDOW)
-    _checkForCallback(win, "OnCharHook",    wxEVT_CHAR_HOOK)
-
-
-def _StdOnScrollCallback(win):
-    try:    cb = getattr(win, "OnScroll")
-    except: pass
-    else:   EVT_SCROLL(win, cb)
-
-
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-# functions that look and act like the C++ Macros of the same name
-
-
-# Miscellaneous
-def EVT_SIZE(win, func):
-    win.Connect(-1, -1, wxEVT_SIZE, func)
-
-def EVT_MOVE(win, func):
-    win.Connect(-1, -1, wxEVT_MOVE, func)
-
-def EVT_CLOSE(win, func):
-    win.Connect(-1, -1, wxEVT_CLOSE_WINDOW, func)
-
-def EVT_PAINT(win, func):
-    win.Connect(-1, -1, wxEVT_PAINT, func)
-
-def EVT_ERASE_BACKGROUND(win, func):
-    win.Connect(-1, -1, wxEVT_ERASE_BACKGROUND, func)
-
-def EVT_CHAR(win, func):
-    win.Connect(-1, -1, wxEVT_CHAR, func)
-
-def EVT_CHAR_HOOK(win, func):
-    win.Connect(-1, -1, wxEVT_CHAR_HOOK, func)
-
-def EVT_MENU_HIGHLIGHT(win, id, func):
-    win.Connect(id, -1, wxEVT_MENU_HIGHLIGHT, func)
-
-def EVT_MENU_HIGHLIGHT_ALL(win, func):
-    win.Connect(-1, -1, wxEVT_MENU_HIGHLIGHT, func)
-
-def EVT_SET_FOCUS(win, func):
-    win.Connect(-1, -1, wxEVT_SET_FOCUS, func)
-
-def EVT_KILL_FOCUS(win, func):
-    win.Connect(-1, -1, wxEVT_KILL_FOCUS, func)
-
-def EVT_ACTIVATE(win, func):
-    win.Connect(-1, -1, wxEVT_ACTIVATE, func)
-
-def EVT_ACTIVATE_APP(win, func):
-    win.Connect(-1, -1, wxEVT_ACTIVATE_APP, func)
-
-def EVT_END_SESSION(win, func):
-    win.Connect(-1, -1, wxEVT_END_SESSION, func)
-
-def EVT_QUERY_END_SESSION(win, func):
-    win.Connect(-1, -1, wxEVT_QUERY_END_SESSION, func)
-
-def EVT_DROP_FILES(win, func):
-    win.Connect(-1, -1, wxEVT_DROP_FILES, func)
-
-def EVT_INIT_DIALOG(win, func):
-    win.Connect(-1, -1, wxEVT_INIT_DIALOG, func)
-
-def EVT_SYS_COLOUR_CHANGED(win, func):
-    win.Connect(-1, -1, wxEVT_SYS_COLOUR_CHANGED, func)
-
-def EVT_SHOW(win, func):
-    win.Connect(-1, -1, wxEVT_SHOW, func)
-
-def EVT_MAXIMIZE(win, func):
-    win.Connect(-1, -1, wxEVT_MAXIMIZE, func)
-
-def EVT_ICONIZE(win, func):
-    win.Connect(-1, -1, wxEVT_ICONIZE, func)
-
-def EVT_NAVIGATION_KEY(win, func):
-    win.Connect(-1, -1, wxEVT_NAVIGATION_KEY, func)
-
-
-# Mouse Events
-def EVT_LEFT_DOWN(win, func):
-    win.Connect(-1, -1, wxEVT_LEFT_DOWN, func)
-
-def EVT_LEFT_UP(win, func):
-    win.Connect(-1, -1, wxEVT_LEFT_UP, func)
-
-def EVT_MIDDLE_DOWN(win, func):
-    win.Connect(-1, -1, wxEVT_MIDDLE_DOWN, func)
-
-def EVT_MIDDLE_UP(win, func):
-    win.Connect(-1, -1, wxEVT_MIDDLE_UP, func)
-
-def EVT_RIGHT_DOWN(win, func):
-    win.Connect(-1, -1, wxEVT_RIGHT_DOWN, func)
-
-def EVT_RIGHT_UP(win, func):
-    win.Connect(-1, -1, wxEVT_RIGHT_UP, func)
-
-def EVT_MOTION(win, func):
-    win.Connect(-1, -1, wxEVT_MOTION, func)
-
-def EVT_LEFT_DCLICK(win, func):
-    win.Connect(-1, -1, wxEVT_LEFT_DCLICK, func)
-
-def EVT_MIDDLE_DCLICK(win, func):
-    win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
-
-def EVT_RIGHT_DCLICK(win, func):
-    win.Connect(-1, -1, wxEVT_RIGHT_DCLICK, func)
-
-def EVT_LEAVE_WINDOW(win, func):
-    win.Connect(-1, -1, wxEVT_LEAVE_WINDOW, func)
-
-def EVT_ENTER_WINDOW(win, func):
-    win.Connect(-1, -1, wxEVT_ENTER_WINDOW, func)
-
-
-# all mouse events
-def EVT_MOUSE_EVENTS(win, func):
-    win.Connect(-1, -1, wxEVT_LEFT_DOWN,     func)
-    win.Connect(-1, -1, wxEVT_LEFT_UP,       func)
-    win.Connect(-1, -1, wxEVT_MIDDLE_DOWN,   func)
-    win.Connect(-1, -1, wxEVT_MIDDLE_UP,     func)
-    win.Connect(-1, -1, wxEVT_RIGHT_DOWN,    func)
-    win.Connect(-1, -1, wxEVT_RIGHT_UP,      func)
-    win.Connect(-1, -1, wxEVT_MOTION,        func)
-    win.Connect(-1, -1, wxEVT_LEFT_DCLICK,   func)
-    win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
-    win.Connect(-1, -1, wxEVT_RIGHT_DCLICK,  func)
-    win.Connect(-1, -1, wxEVT_LEAVE_WINDOW,  func)
-    win.Connect(-1, -1, wxEVT_ENTER_WINDOW,  func)
-
-# EVT_COMMAND
-def EVT_COMMAND(win, id, cmd, func):
-    win.Connect(id, -1, cmd, func)
-
-def EVT_COMMAND_RANGE(win, id1, id2, cmd, func):
-    win.Connect(id1, id2, cmd, func)
-
-# Scrolling
-def EVT_SCROLL(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_TOP,       func)
-    win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM,    func)
-    win.Connect(-1, -1, wxEVT_SCROLL_LINEUP,    func)
-    win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN,  func)
-    win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP,    func)
-    win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN,  func)
-    win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK,func)
-
-def EVT_SCROLL_TOP(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_TOP, func)
-
-def EVT_SCROLL_BOTTOM(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM, func)
-
-def EVT_SCROLL_LINEUP(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_LINEUP, func)
-
-def EVT_SCROLL_LINEDOWN(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN, func)
-
-def EVT_SCROLL_PAGEUP(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP, func)
-
-def EVT_SCROLL_PAGEDOWN(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN, func)
-
-def EVT_SCROLL_THUMBTRACK(win, func):
-    win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK, func)
-
-
-
-# Scrolling, with an id
-def EVT_COMMAND_SCROLL(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_TOP,       func)
-    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM,    func)
-    win.Connect(id, -1, wxEVT_SCROLL_LINEUP,    func)
-    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN,  func)
-    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP,    func)
-    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN,  func)
-    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
-
-def EVT_COMMAND_SCROLL_TOP(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_TOP, func)
-
-def EVT_COMMAND_SCROLL_BOTTOM(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM, func)
-
-def EVT_COMMAND_SCROLL_LINEUP(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
-
-def EVT_COMMAND_SCROLL_LINEDOWN(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN, func)
-
-def EVT_COMMAND_SCROLL_PAGEUP(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP, func)
-
-def EVT_COMMAND_SCROLL_PAGEDOWN(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN, func)
-
-def EVT_COMMAND_SCROLL_THUMBTRACK(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK, func)
-
-
-# Convenience commands
-def EVT_BUTTON(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_BUTTON_CLICKED, func)
-
-def EVT_CHECKBOX(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_CHECKBOX_CLICKED, func)
-
-def EVT_CHOICE(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_CHOICE_SELECTED, func)
-
-def EVT_LISTBOX(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_SELECTED, func)
-
-def EVT_LISTBOX_DCLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, func)
-
-def EVT_TEXT(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TEXT_UPDATED, func)
-
-def EVT_TEXT_ENTER(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TEXT_ENTER, func)
-
-def EVT_MENU(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_MENU_SELECTED, func)
-
-def EVT_MENU_RANGE(win, id1, id2, func):
-    win.Connect(id1, id2, wxEVT_COMMAND_MENU_SELECTED, func)
-
-def EVT_SLIDER(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_SLIDER_UPDATED, func)
-
-def EVT_RADIOBOX(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_RADIOBOX_SELECTED, func)
-
-def EVT_RADIOBUTTON(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_RADIOBUTTON_SELECTED, func)
-
-def EVT_VLBOX(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_VLBOX_SELECTED, func)
-
-def EVT_COMBOBOX(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_COMBOBOX_SELECTED, func)
-
-def EVT_TOOL(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TOOL_CLICKED, func)
-
-def EVT_TOOL_RCLICKED(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TOOL_RCLICKED, func)
-
-def EVT_TOOL_ENTER(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TOOL_ENTER, func)
-
-def EVT_CHECKLISTBOX(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, func)
-
-
-# Generic command events
-
-def EVT_COMMAND_LEFT_CLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LEFT_CLICK, func)
-
-def EVT_COMMAND_LEFT_DCLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LEFT_DCLICK, func)
-
-def EVT_COMMAND_RIGHT_CLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_RIGHT_CLICK, func)
-
-def EVT_COMMAND_RIGHT_DCLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_RIGHT_DCLICK, func)
-
-def EVT_COMMAND_SET_FOCUS(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_SET_FOCUS, func)
-
-def EVT_COMMAND_KILL_FOCUS(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_KILL_FOCUS, func)
-
-def EVT_COMMAND_ENTER(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_ENTER, func)
-
-
-# wxNotebook events
-def EVT_NOTEBOOK_PAGE_CHANGED(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, func)
-
-def EVT_NOTEBOOK_PAGE_CHANGING(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, func)
-
-
-# wxTreeCtrl events
-def EVT_TREE_BEGIN_DRAG(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_DRAG, func)
-
-def EVT_TREE_BEGIN_RDRAG(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_RDRAG, func)
-
-def EVT_TREE_BEGIN_LABEL_EDIT(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, func)
-
-def EVT_TREE_END_LABEL_EDIT(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_END_LABEL_EDIT, func)
-
-def EVT_TREE_GET_INFO(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_GET_INFO, func)
-
-def EVT_TREE_SET_INFO(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_SET_INFO, func)
-
-def EVT_TREE_ITEM_EXPANDED(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDED, func)
-
-def EVT_TREE_ITEM_EXPANDING(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDING, func)
-
-def EVT_TREE_ITEM_COLLAPSED(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSED, func)
-
-def EVT_TREE_ITEM_COLLAPSING(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSING, func)
-
-def EVT_TREE_SEL_CHANGED(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGED, func)
-
-def EVT_TREE_SEL_CHANGING(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGING, func)
-
-def EVT_TREE_KEY_DOWN(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_KEY_DOWN, func)
-
-def EVT_TREE_DELETE_ITEM(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_TREE_DELETE_ITEM, func)
-
-
-# wxSpinButton
-def EVT_SPIN_UP(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
-
-def EVT_SPIN_DOWN(win, id, func):
-    win.Connect(id, -1,wxEVT_SCROLL_LINEDOWN, func)
-
-def EVT_SPIN(win, id, func):
-    win.Connect(id, -1, wxEVT_SCROLL_TOP,       func)
-    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM,    func)
-    win.Connect(id, -1, wxEVT_SCROLL_LINEUP,    func)
-    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN,  func)
-    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP,    func)
-    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN,  func)
-    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
-
-
-
-
-# wxTaskBarIcon
-def EVT_TASKBAR_MOVE(win, func):
-    win.Connect(-1, -1, wxEVT_TASKBAR_MOVE, func)
-
-def EVT_TASKBAR_LEFT_DOWN(win, func):
-    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DOWN, func)
-
-def EVT_TASKBAR_LEFT_UP(win, func):
-    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_UP, func)
-
-def EVT_TASKBAR_RIGHT_DOWN(win, func):
-    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DOWN, func)
-
-def EVT_TASKBAR_RIGHT_UP(win, func):
-    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_UP, func)
-
-def EVT_TASKBAR_LEFT_DCLICK(win, func):
-    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DCLICK, func)
-
-def EVT_TASKBAR_RIGHT_DCLICK(win, func):
-    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DCLICK, func)
-
-
-# wxGrid
-def EVT_GRID_SELECT_CELL(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_SELECT_CELL, fn)
-
-def EVT_GRID_CREATE_CELL(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_CREATE_CELL, fn)
-
-def EVT_GRID_CHANGE_LABELS(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_CHANGE_LABELS, fn)
-
-def EVT_GRID_CHANGE_SEL_LABEL(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_CHANGE_SEL_LABEL, fn)
-
-def EVT_GRID_CELL_CHANGE(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_CELL_CHANGE, fn)
-
-def EVT_GRID_CELL_LCLICK(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_CELL_LCLICK, fn)
-
-def EVT_GRID_CELL_RCLICK(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_CELL_RCLICK, fn)
-
-def EVT_GRID_LABEL_LCLICK(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_LABEL_LCLICK, fn)
-
-def EVT_GRID_LABEL_RCLICK(win, fn):
-    win.Connect(-1, -1, wxEVT_GRID_LABEL_RCLICK, fn)
-
-
-# wxSashWindow
-def EVT_SASH_DRAGGED(win, id, func):
-    win.Connect(id, -1, wxEVT_SASH_DRAGGED, func)
-
-def EVT_SASH_DRAGGED_RANGE(win, id1, id2, func):
-    win.Connect(id1, id2, wxEVT_SASH_DRAGGED, func)
-
-def EVT_QUERY_LAYOUT_INFO(win, func):
-    win.Connect(-1, -1, wxEVT_EVT_QUERY_LAYOUT_INFO, func)
-
-def EVT_CALCULATE_LAYOUT(win, func):
-    win.Connect(-1, -1, wxEVT_EVT_CALCULATE_LAYOUT, func)
-
-
-# wxListCtrl
-def EVT_LIST_BEGIN_DRAG(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_DRAG, func)
-
-def EVT_LIST_BEGIN_RDRAG(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_RDRAG, func)
-
-def EVT_LIST_BEGIN_LABEL_EDIT(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, func)
-
-def EVT_LIST_END_LABEL_EDIT(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_END_LABEL_EDIT, func)
-
-def EVT_LIST_DELETE_ITEM(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_DELETE_ITEM, func)
-
-def EVT_LIST_DELETE_ALL_ITEMS(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, func)
-
-def EVT_LIST_GET_INFO(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_GET_INFO, func)
-
-def EVT_LIST_SET_INFO(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_SET_INFO, func)
-
-def EVT_LIST_ITEM_SELECTED(win, id, func):
-    win.Connect(id, -1,  wxEVT_COMMAND_LIST_ITEM_SELECTED, func)
-
-def EVT_LIST_ITEM_DESELECTED(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_DESELECTED, func)
-
-def EVT_LIST_KEY_DOWN(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_KEY_DOWN, func)
-
-def EVT_LIST_INSERT_ITEM(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_INSERT_ITEM, func)
-
-def EVT_LIST_COL_CLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_COMMAND_LIST_COL_CLICK, func)
-
-
-#----------------------------------------------------------------------
-
-class wxTimer(wxPyTimer):
-    def __init__(self):
-        wxPyTimer.__init__(self, self.Notify)   # derived class must provide
-                                                # Notify(self) method.
-
-#----------------------------------------------------------------------
-# Some wxWin methods can take "NULL" as parameters, but the shadow classes
-# expect an object with the SWIG pointer as a 'this' member.  This class
-# and instance fools the shadow into passing the NULL pointer.
-
-class NullObj:
-    this = 'NULL'       # SWIG converts this to (void*)0
-
-NULL = NullObj()
-
-
-#----------------------------------------------------------------------
-# aliases
-
-wxColor      = wxColour
-wxNamedColor = wxNamedColour
-
-wxPyDefaultPosition.Set(-1,-1)
-wxPyDefaultSize.Set(-1,-1)
-
-# aliases so that C++ documentation applies:
-wxDefaultPosition = wxPyDefaultPosition
-wxDefaultSize     = wxPyDefaultSize
-
-#----------------------------------------------------------------------
-
-## class wxPyStdOutWindow(wxFrame):
-##     def __init__(self, title = "wxPython: stdout/stderr"):
-##         wxFrame.__init__(self, NULL, title)
-##         self.title = title
-##         self.text = wxTextWindow(self)
-##         self.text.SetFont(wxFont(10, wxMODERN, wxNORMAL, wxBOLD))
-##         self.SetSize(-1,-1,400,200)
-##         self.Show(false)
-##         self.isShown = false
-
-##     def write(self, str):  # with this method,
-##         if not self.isShown:
-##             self.Show(true)
-##             self.isShown = true
-##         self.text.WriteText(str)
-
-##     def OnCloseWindow(self, event): # doesn't allow the window to close, just hides it
-##         self.Show(false)
-##         self.isShown = false
-
-
-_defRedirect = (wxPlatform == '__WXMSW__')
-
-#----------------------------------------------------------------------
-# The main application class.  Derive from this and implement an OnInit
-# method that creates a frame and then calls self.SetTopWindow(frame)
-
-class wxApp(wxPyApp):
-    error = 'wxApp.error'
-
-    def __init__(self, redirect=_defRedirect, filename=None):
-        wxPyApp.__init__(self)
-        self.stdioWin = None
-        self.saveStdio = (sys.stdout, sys.stderr)
-        if redirect:
-            self.RedirectStdio(filename)
-
-        # this initializes wxWindows and then calls our OnInit
-        _wxStart(self.OnInit)
-
-
-    def __del__(self):
-        try:
-            self.RestoreStdio()
-        except:
-            pass
-
-    def RedirectStdio(self, filename):
-        if filename:
-            sys.stdout = sys.stderr = open(filename, 'a')
-        else:
-            raise self.error, 'wxPyStdOutWindow not yet implemented.'
-            #self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow()
-
-    def RestoreStdio(self):
-        sys.stdout, sys.stderr = self.saveStdio
-        if self.stdioWin != None:
-            self.stdioWin.Show(false)
-            self.stdioWin.Destroy()
-            self.stdioWin = None
-
-
-#----------------------------------------------------------------------------
-#
-# $Log$
-# Revision 1.10  1999/02/01 00:10:39  RD
-# Added the missing EVT_LIST_ITEM_SELECTED and friends.
-#
-# Revision 1.9  1999/01/30 07:30:09  RD
-#
-# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-#
-# Various cleanup, tweaks, minor additions, etc. to maintain
-# compatibility with the current wxWindows.
-#
-# Revision 1.8  1999/01/29 21:13:42  HH
-# Added aliases for wxDefaultPosition and wxDefaultSize (from wxPy..) in _extras,
-# so that C++ documentation applies.
-#
-# Revision 1.7  1998/11/25 08:45:21  RD
-#
-# Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
-# Added events for wxGrid
-# Other various fixes and additions
-#
-# Revision 1.6  1998/11/16 00:00:52  RD
-# Generic treectrl for wxPython/GTK compiles...
-#
-# Revision 1.5  1998/10/20 07:38:02  RD
-# bug fix
-#
-# Revision 1.4  1998/10/20 06:43:54  RD
-# New wxTreeCtrl wrappers (untested)
-# some changes in helpers
-# etc.
-#
-# Revision 1.3  1998/10/02 06:40:33  RD
-#
-# Version 0.4 of wxPython for MSW.
-#
-# Revision 1.2  1998/08/18 19:48:12  RD
-# more wxGTK compatibility things.
-#
-# It builds now but there are serious runtime problems...
-#
-# Revision 1.1  1998/08/09 08:25:49  RD
-# Initial version
-#
-#
-

utils/wxPython/src/cmndlgs.i

@@ -1,359 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        cmndlgs.i
-// Purpose:     SWIG definitions for the Common Dialog Classes
-//
-// Author:      Robin Dunn
-//
-// Created:     7/25/98
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module cmndlgs
-
-%{
-#include "helpers.h"
-#include <wx/colordlg.h>
-#include <wx/dirdlg.h>
-#include <wx/fontdlg.h>
-#include <wx/printdlg.h>
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-%import misc.i
-%import gdi.i
-%import windows.i
-
-%pragma(python) code = "import wx"
-
-//----------------------------------------------------------------------
-
-class wxColourData {
-public:
-    wxColourData();
-    ~wxColourData();
-
-    bool GetChooseFull();
-    wxColour& GetColour();
-    wxColour GetCustomColour(int i);
-    void SetChooseFull(int flag);
-    void SetColour(const wxColour& colour);
-    void SetCustomColour(int i, const wxColour& colour);
-};
-
-
-class wxColourDialog : public wxDialog {
-public:
-    wxColourDialog(wxWindow* parent, wxColourData* data = NULL);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    wxColourData& GetColourData();
-    int ShowModal();
-};
-
-
-//----------------------------------------------------------------------
-
-class wxDirDialog : public wxDialog {
-public:
-    wxDirDialog(wxWindow* parent,
-                char* message = "Choose a directory",
-                char* defaultPath = "",
-                long style = 0,
-                const wxPoint& pos = wxPyDefaultPosition);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    wxString GetPath();
-    wxString GetMessage();
-    long GetStyle();
-    void SetMessage(const wxString& message);
-    void SetPath(const wxString& path);
-    int ShowModal();
-};
-
-//----------------------------------------------------------------------
-
-class wxFileDialog : public wxDialog {
-public:
-    wxFileDialog(wxWindow* parent,
-                 char* message = "Choose a file",
-                 char* defaultDir = "",
-                 char* defaultFile = "",
-                 char* wildcard = "*.*",
-                 long style = 0,
-                 const wxPoint& pos = wxPyDefaultPosition);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    wxString GetDirectory();
-    wxString GetFilename();
-    int GetFilterIndex();
-    wxString GetMessage();
-    wxString GetPath();
-    long GetStyle();
-    wxString GetWildcard();
-    void SetDirectory(const wxString& directory);
-    void SetFilename(const wxString& setfilename);
-    void SetFilterIndex(int filterIndex);
-    void SetMessage(const wxString& message);
-    void SetPath(const wxString& path);
-    void SetStyle(long style);
-    void SetWildcard(const wxString& wildCard);
-    int ShowModal();
-};
-
-
-//----------------------------------------------------------------------
-
-//TODO: wxMultipleChoiceDialog
-
-//----------------------------------------------------------------------
-
-class wxSingleChoiceDialog : public wxDialog {
-public:
-    %addmethods {
-        // TODO: ignoring clientData for now...
-        //       SWIG is messing up the &/*'s for some reason.
-        wxSingleChoiceDialog(wxWindow* parent,
-                             wxString* message,
-                             wxString* caption,
-                             int LCOUNT, wxString* LIST,
-                             //char** clientData = NULL,
-                             long style = wxOK | wxCANCEL | wxCENTRE,
-                             wxPoint* pos = &wxPyDefaultPosition) {
-            return new wxSingleChoiceDialog(parent, *message, *caption,
-                                            LCOUNT, LIST, NULL, style, *pos);
-        }
-    }
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    int GetSelection();
-    wxString GetStringSelection();
-    void SetSelection(int sel);
-    int ShowModal();
-};
-
-
-//----------------------------------------------------------------------
-
-class wxTextEntryDialog : public wxDialog {
-public:
-    wxTextEntryDialog(wxWindow* parent,
-                      char* message,
-                      char* caption = "Input Text",
-                      char* defaultValue = "",
-                      long style = wxOK | wxCANCEL | wxCENTRE,
-                      const wxPoint& pos = wxPyDefaultPosition);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    wxString GetValue();
-    void SetValue(const wxString& value);
-    int ShowModal();
-};
-
-//----------------------------------------------------------------------
-
-class wxFontData {
-public:
-    wxFontData();
-    ~wxFontData();
-
-    void EnableEffects(bool enable);
-    bool GetAllowSymbols();
-    wxColour& GetColour();
-    wxFont GetChosenFont();
-    bool GetEnableEffects();
-    wxFont GetInitialFont();
-    bool GetShowHelp();
-    void SetAllowSymbols(bool allowSymbols);
-    void SetChosenFont(const wxFont& font);
-    void SetColour(const wxColour& colour);
-    void SetInitialFont(const wxFont& font);
-    void SetRange(int min, int max);
-    void SetShowHelp(bool showHelp);
-};
-
-
-class wxFontDialog : public wxDialog {
-public:
-    wxFontDialog(wxWindow* parent, wxFontData* data = NULL);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    wxFontData& GetFontData();
-    int ShowModal();
-};
-
-
-//----------------------------------------------------------------------
-
-class wxPageSetupData {
-public:
-    wxPageSetupData();
-    ~wxPageSetupData();
-
-    void EnableHelp(bool flag);
-    void EnableMargins(bool flag);
-    void EnableOrientation(bool flag);
-    void EnablePaper(bool flag);
-    void EnablePrinter(bool flag);
-    wxPoint GetPaperSize();
-    wxPoint GetMarginTopLeft();
-    wxPoint GetMarginBottomRight();
-    wxPoint GetMinMarginTopLeft();
-    wxPoint GetMinMarginBottomRight();
-    int GetOrientation();
-    bool GetDefaultMinMargins();
-    bool GetEnableMargins();
-    bool GetEnableOrientation();
-    bool GetEnablePaper();
-    bool GetEnablePrinter();
-    bool GetEnableHelp();
-    bool GetDefaultInfo();
-    void SetPaperSize(const wxPoint& size);
-    void SetMarginTopLeft(const wxPoint& pt);
-    void SetMarginBottomRight(const wxPoint& pt);
-    void SetMinMarginTopLeft(const wxPoint& pt);
-    void SetMinMarginBottomRight(const wxPoint& pt);
-    void SetOrientation(int orientation);
-    void SetDefaultMinMargins(bool flag);
-    void SetDefaultInfo(bool flag);
-};
-
-
-class wxPageSetupDialog : public wxDialog {
-public:
-    wxPageSetupDialog(wxWindow* parent, wxPageSetupData* data = NULL);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    wxPageSetupData& GetPageSetupData();
-    int ShowModal();
-};
-
-//----------------------------------------------------------------------
-
-class wxPrintData {
-public:
-    wxPrintData();
-    ~wxPrintData();
-
-    void EnableHelp(bool flag);
-    void EnablePageNumbers(bool flag);
-    void EnablePrintToFile(bool flag);
-    void EnableSelection(bool flag);
-    bool GetAllPages();
-    bool GetCollate();
-    int GetFromPage();
-    int GetMaxPage();
-    int GetMinPage();
-    int GetNoCopies();
-    int GetOrientation();
-    int GetToPage();
-    void SetCollate(bool flag);
-    void SetFromPage(int page);
-    void SetMaxPage(int page);
-    void SetMinPage(int page);
-    void SetOrientation(int orientation);
-    void SetNoCopies(int n);
-    void SetPrintToFile(bool flag);
-    void SetSetupDialog(bool flag);
-    void SetToPage(int page);
-};
-
-
-class wxPrintDialog : public wxDialog {
-public:
-    wxPrintDialog(wxWindow* parent, wxPrintData* data = NULL);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    wxPrintData& GetPrintData();
-    %new wxDC* GetPrintDC();
-    int ShowModal();
-};
-
-//----------------------------------------------------------------------
-
-class wxMessageDialog : public wxDialog {
-public:
-    wxMessageDialog(wxWindow* parent,
-                    char* message,
-                    char* caption = "Message box",
-                    long style = wxOK | wxCANCEL | wxCENTRE,
-                    const wxPoint& pos = wxPyDefaultPosition);
-
-    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
-
-    int ShowModal();
-};
-
-//----------------------------------------------------------------------
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.8  1998/12/17 14:07:25  RR
-//   Removed minor differences between wxMSW and wxGTK
-//
-// Revision 1.7  1998/12/15 20:41:14  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.6  1998/11/25 08:45:22  RD
-//
-// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
-// Added events for wxGrid
-// Other various fixes and additions
-//
-// Revision 1.5  1998/11/15 23:03:43  RD
-// Removing some ifdef's for wxGTK
-//
-// Revision 1.4  1998/10/02 06:40:34  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.3  1998/08/18 19:48:13  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.2  1998/08/15 07:36:25  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.1  1998/08/09 08:25:49  RD
-// Initial version
-//
-//
-

utils/wxPython/src/controls.i

@@ -1,543 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        controls.i
-// Purpose:     Control (widget) classes for wxPython
-//
-// Author:      Robin Dunn
-//
-// Created:     6/10/98
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module controls
-
-%{
-#include "helpers.h"
-#include <wx/slider.h>
-#include <wx/spinbutt.h>
-
-#ifdef __WXMSW__
-#if wxUSE_OWNER_DRAWN
-#include <wx/checklst.h>
-#endif
-#endif
-
-#ifdef __WXGTK__
-#include <wx/checklst.h>
-#endif
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-%import misc.i
-%import windows.i
-%import gdi.i
-%import events.i
-
-%pragma(python) code = "import wx"
-
-//----------------------------------------------------------------------
-
-%{
-wxValidator wxPyDefaultValidator;       // Non-const default because of SWIG
-%}
-
-//----------------------------------------------------------------------
-
-class wxControl : public wxWindow {
-public:
-    void Command(wxCommandEvent& event);
-    wxString GetLabel();
-    void SetLabel(const wxString& label);
-};
-
-//----------------------------------------------------------------------
-
-class wxButton : public wxControl {
-public:
-    wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
-             const wxPoint& pos = wxPyDefaultPosition,
-             const wxSize& size = wxPyDefaultSize,
-             long style = 0,
-             const wxValidator& validator = wxPyDefaultValidator,
-             char* name = "button");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    void SetDefault();
-};
-
-//----------------------------------------------------------------------
-
-class wxBitmapButton : public wxButton {
-public:
-    wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
-                   const wxPoint& pos = wxPyDefaultPosition,
-                   const wxSize& size = wxPyDefaultSize,
-                   long style = wxBU_AUTODRAW,
-                   const wxValidator& validator = wxPyDefaultValidator,
-                   char* name = "button");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    wxBitmap& GetBitmapLabel();
-    wxBitmap& GetBitmapDisabled();
-    wxBitmap& GetBitmapFocus();
-    wxBitmap& GetBitmapSelected();
-    void SetBitmapDisabled(const wxBitmap& bitmap);
-    void SetBitmapFocus(const wxBitmap& bitmap);
-    void SetBitmapSelected(const wxBitmap& bitmap);
-    void SetBitmapLabel(const wxBitmap& bitmap);
-
-};
-
-//----------------------------------------------------------------------
-
-class wxCheckBox : public wxControl {
-public:
-    wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
-               const wxPoint& pos = wxPyDefaultPosition,
-               const wxSize& size = wxPyDefaultSize,
-               long style = 0,
-               const wxValidator& val = wxPyDefaultValidator,
-               char* name = "checkBox");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    bool GetValue();
-    void SetValue(const bool state);
-};
-
-//----------------------------------------------------------------------
-
-class wxChoice : public wxControl {
-public:
-    wxChoice(wxWindow *parent, wxWindowID id,
-             const wxPoint& pos = wxPyDefaultPosition,
-             const wxSize& size = wxPyDefaultSize,
-             int LCOUNT=0, wxString* LIST=NULL,
-             long style = 0,
-             const wxValidator& validator = wxPyDefaultValidator,
-             char* name = "choice");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    void Append(const wxString& item);
-    void Clear();
-    int FindString(const wxString& string);
-    int GetColumns();
-    int GetSelection();
-    wxString GetString(const int n);
-    wxString GetStringSelection();
-    int Number();
-    void SetColumns(const int n = 1);
-    void SetSelection(const int n);
-    void SetStringSelection(const wxString& string);
-};
-
-//----------------------------------------------------------------------
-
-class wxComboBox : public wxControl {
-public:
-    wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
-               const wxPoint& pos = wxPyDefaultPosition,
-               const wxSize& size = wxPyDefaultSize,
-               int LCOUNT=0, wxString* LIST=NULL,
-               long style = 0,
-               const wxValidator& validator = wxPyDefaultValidator,
-               char* name = "comboBox");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    void Append(const wxString& item);
-    // TODO: void Append(const wxString& item, char* clientData);
-    void Clear();
-    void Copy();
-    void Cut();
-    void Delete(int n);
-    // NotMember??:    void Deselect(int n);
-    int FindString(const wxString& string);
-    // TODO: char* GetClientData(const int n);
-    long GetInsertionPoint();
-    long GetLastPosition();
-    int GetSelection();
-    wxString GetString(int n);
-    wxString GetStringSelection();
-    wxString GetValue();
-    int Number();
-    void Paste();
-    void Replace(long from, long to, const wxString& text);
-    void Remove(long from, long to);
-    // TODO:    void SetClientData(const int n, char* data);
-    void SetInsertionPoint(long pos);
-    void SetInsertionPointEnd();
-    void SetSelection(int n, bool select = TRUE);
-    %name(SetMark)void SetSelection(long from, long to);
-    void SetValue(const wxString& text);
-};
-
-//----------------------------------------------------------------------
-
-class wxGauge : public wxControl {
-public:
-    wxGauge(wxWindow* parent, wxWindowID id, int range,
-            const wxPoint& pos = wxPyDefaultPosition,
-            const wxSize& size = wxPyDefaultSize,
-            long style = wxGA_HORIZONTAL,
-            const wxValidator& validator = wxPyDefaultValidator,
-            char* name = "gauge");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    int GetBezelFace();
-    int GetRange();
-    int GetShadowWidth();
-    int GetValue();
-    void SetBezelFace(int width);
-    void SetRange(int range);
-    void SetShadowWidth(int width);
-    void SetValue(int pos);
-};
-
-//----------------------------------------------------------------------
-
-class wxStaticBox : public wxControl {
-public:
-    wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
-                const wxPoint& pos = wxPyDefaultPosition,
-                const wxSize& size = wxPyDefaultSize,
-                long style = 0,
-                char* name = "staticBox");
-};
-
-
-//----------------------------------------------------------------------
-
-class wxStaticText : public wxControl {
-public:
-    wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
-                 const wxPoint& pos = wxPyDefaultPosition,
-                 const wxSize& size = wxPyDefaultSize,
-                 long style = 0,
-                 char* name = "staticText");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    wxString GetLabel();
-    void SetLabel(const wxString& label);
-};
-
-//----------------------------------------------------------------------
-
-class wxListBox : public wxControl {
-public:
-    wxListBox(wxWindow* parent, wxWindowID id,
-              const wxPoint& pos = wxPyDefaultPosition,
-              const wxSize& size = wxPyDefaultSize,
-              int LCOUNT, wxString* LIST = NULL,
-              long style = 0,
-              const wxValidator& validator = wxPyDefaultValidator,
-              char* name = "listBox");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    void Append(const wxString& item);
-    // TODO:    void Append(const wxString& item, char* clientData);
-    void Clear();
-    void Delete(int n);
-    void Deselect(int n);
-    int FindString(const wxString& string);
-    // TODO:    char* GetClientData(const int n);
-    int GetSelection();
-    // TODO: int GetSelections(int **selections);
-    wxString GetString(int n);
-    wxString GetStringSelection();
-    int Number();
-    bool Selected(const int n);
-    void Set(int LCOUNT, wxString* LIST);
-    // TODO:    void SetClientData(const int n, char* data);
-    void SetFirstItem(int n);
-    %name(SetFirstItemStr)void SetFirstItem(const wxString& string);
-    void SetSelection(int n, bool select = TRUE);
-    void SetString(int n, const wxString& string);
-    void SetStringSelection(const wxString& string, bool select = TRUE);
-};
-
-
-//----------------------------------------------------------------------
-
-class wxCheckListBox : public wxListBox {
-public:
-    wxCheckListBox(wxWindow *parent, wxWindowID id,
-                   const wxPoint& pos = wxPyDefaultPosition,
-                   const wxSize& size = wxPyDefaultSize,
-                   int LCOUNT = 0,
-                   wxString* LIST = NULL,
-                   long style = 0,
-                   const wxValidator& validator = wxPyDefaultValidator,
-                   char* name = "listBox");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    bool  IsChecked(int uiIndex);
-    void  Check(int uiIndex, bool bCheck = TRUE);
-
-    int GetItemHeight();
-};
-
-//----------------------------------------------------------------------
-
-class wxTextCtrl : public wxControl {
-public:
-    wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
-               const wxPoint& pos = wxPyDefaultPosition,
-               const wxSize& size = wxPyDefaultSize,
-               long style = 0,
-               const wxValidator& validator = wxPyDefaultValidator,
-               char* name = "text");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    void Clear();
-    void Copy();
-    void Cut();
-    void DiscardEdits();
-    long GetInsertionPoint();
-    long GetLastPosition();
-    int GetLineLength(long lineNo);
-    wxString GetLineText(long lineNo);
-    int GetNumberOfLines();
-    wxString GetValue();
-    bool IsModified();
-    bool LoadFile(const wxString& filename);
-    void Paste();
-    void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
-    void Remove(long from, long to);
-    void Replace(long from, long to, const wxString& value);
-    bool SaveFile(const wxString& filename);
-    void SetEditable(bool editable);
-    void SetInsertionPoint(long pos);
-    void SetInsertionPointEnd();
-    void SetSelection(long from, long to);
-    void SetValue(const wxString& value);
-    void ShowPosition(long pos);
-    void WriteText(const wxString& text);
-    long XYToPosition(long x, long y);
-};
-
-//----------------------------------------------------------------------
-
-class wxScrollBar : public wxControl {
-public:
-    wxScrollBar(wxWindow* parent, wxWindowID id = -1,
-                const wxPoint& pos = wxPyDefaultPosition,
-                const wxSize& size = wxPyDefaultSize,
-                long style = wxSB_HORIZONTAL,
-                const wxValidator& validator = wxPyDefaultValidator,
-                char* name = "scrollBar");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    int GetRange();
-    int GetPageSize();
-    int GetThumbPosition();
-    int GetThumbSize();
-    void SetThumbPosition(int viewStart);
-    void SetScrollbar(int position, int thumbSize,
-                      int range,    int pageSize,
-                      bool refresh = TRUE);
-};
-
-//----------------------------------------------------------------------
-
-class wxSpinButton : public wxControl {
-public:
-    wxSpinButton(wxWindow* parent, wxWindowID id = -1,
-                 const wxPoint& pos = wxPyDefaultPosition,
-                 const wxSize& size = wxPyDefaultSize,
-                 long style = wxSP_HORIZONTAL,
-                 char* name = "spinButton");
-
-    int GetMax();
-    int GetMin();
-    int GetValue();
-    void SetRange(int min, int max);
-    void SetValue(int value);
-};
-
-//----------------------------------------------------------------------
-
-class wxStaticBitmap : public wxControl {
-public:
-    wxStaticBitmap(wxWindow* parent, wxWindowID id,
-                   const wxBitmap& bitmap,
-                   const wxPoint& pos = wxPyDefaultPosition,
-                   const wxSize& size = wxPyDefaultSize,
-                   long style = 0,
-                   char* name = "staticBitmap");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    wxBitmap& GetBitmap();
-    void SetBitmap(const wxBitmap& bitmap);
-};
-
-//----------------------------------------------------------------------
-
-class wxRadioBox : public wxControl {
-public:
-    wxRadioBox(wxWindow* parent, wxWindowID id,
-               const wxString& label,
-               const wxPoint& point = wxPyDefaultPosition,
-               const wxSize& size = wxPyDefaultSize,
-               int LCOUNT = 0, wxString* LIST = NULL,
-               int majorDimension = 0,
-               long style = wxRA_HORIZONTAL,
-               const wxValidator& validator = wxPyDefaultValidator,
-               char* name = "radioBox");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    %name(EnableBox)void Enable(bool enable);
-    void Enable(int n, bool enable);
-    int FindString(const wxString& string);
-#ifdef __WXMSW__
-    %name(GetBoxLabel)wxString GetLabel();
-#endif
-    wxString GetLabel(int n);
-    int GetSelection();
-    wxString GetString(int n);
-    wxString GetStringSelection();
-    int Number();
-    %name(SetBoxLabel)void SetLabel(const wxString& label);
-    void SetLabel(int n, const wxString& label);
-    void SetSelection(int n);
-    void SetStringSelection(const wxString& string);
-    void Show(bool show);
-    %name(ShowItem)void Show(int item, bool show);
-};
-
-//----------------------------------------------------------------------
-
-class wxRadioButton : public wxControl {
-public:
-    wxRadioButton(wxWindow* parent, wxWindowID id,
-                  const wxString& label,
-                  const wxPoint& pos = wxPyDefaultPosition,
-                  const wxSize& size = wxPyDefaultSize,
-                  long style = 0,
-                  const wxValidator& validator = wxPyDefaultValidator,
-                  char* name = "radioButton");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    bool GetValue();
-    void SetValue(bool value);
-};
-
-//----------------------------------------------------------------------
-
-class wxSlider : public wxControl {
-public:
-    wxSlider(wxWindow* parent, wxWindowID id,
-             int value, int minValue, int maxValue,
-             const wxPoint& point = wxPyDefaultPosition,
-             const wxSize& size = wxPyDefaultSize,
-             long style = wxSL_HORIZONTAL,
-             const wxValidator& validator = wxPyDefaultValidator,
-             char* name = "slider");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    void ClearSel();
-    void ClearTicks();
-    int GetLineSize();
-    int GetMax();
-    int GetMin();
-    int GetPageSize();
-    int GetSelEnd();
-    int GetSelStart();
-    int GetThumbLength();
-    int GetTickFreq();
-    int GetValue();
-    void SetRange(int minValue, int maxValue);
-    void SetTickFreq(int n, int pos);
-    void SetLineSize(int lineSize);
-    void SetPageSize(int pageSize);
-    void SetSelection(int startPos, int endPos);
-    void SetThumbLength(int len);
-    void SetTick(int tickPos);
-    void SetValue(int value);
-};
-
-
-//----------------------------------------------------------------------
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.10  1998/12/17 17:52:19  RD
-// wxPython 0.5.2
-// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
-// versions are much closer now!
-//
-// Revision 1.9  1998/12/17 14:07:29  RR
-//
-//   Removed minor differences between wxMSW and wxGTK
-//
-// Revision 1.8  1998/12/15 20:41:15  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.7  1998/11/16 00:00:53  RD
-// Generic treectrl for wxPython/GTK compiles...
-//
-// Revision 1.6  1998/11/15 23:03:43  RD
-// Removing some ifdef's for wxGTK
-//
-// Revision 1.5  1998/10/07 07:34:32  RD
-// Version 0.4.1 for wxGTK
-//
-// Revision 1.4  1998/10/02 06:40:35  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.3  1998/08/18 19:48:14  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.2  1998/08/15 07:36:28  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.1  1998/08/09 08:25:49  RD
-// Initial version
-//
-//
-

utils/wxPython/src/controls2.i

@@ -1,451 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        controls2.i
-// Purpose:     More control (widget) classes for wxPython
-//
-// Author:      Robin Dunn
-//
-// Created:     6/10/98
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module controls2
-
-%{
-#include "helpers.h"
-#include <wx/listctrl.h>
-#include <wx/treectrl.h>
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-%import misc.i
-%import windows.i
-%import gdi.i
-%import events.i
-%import controls.i
-
-%pragma(python) code = "import wx"
-
-//----------------------------------------------------------------------
-
-%{
-extern wxValidator wxPyDefaultValidator;
-%}
-
-//----------------------------------------------------------------------
-
-class wxListItem {
-public:
-    long            m_mask;     // Indicates what fields are valid
-    long            m_itemId;   // The zero-based item position
-    int             m_col;      // Zero-based column, if in report mode
-    long            m_state;    // The state of the item
-    long            m_stateMask; // Which flags of m_state are valid (uses same flags)
-    wxString        m_text;     // The label/header text
-    int             m_image;    // The zero-based index into an image list
-    long            m_data;     // App-defined data
-//    wxColour       *m_colour;   // only wxGLC, not supported by Windows ;->
-
-    // For columns only
-    int             m_format;   // left, right, centre
-    int             m_width;    // width of column
-
-    wxListItem();
-    ~wxListItem();
-};
-
-class wxListEvent: public wxCommandEvent {
-public:
-    int           m_code;
-    long          m_itemIndex;
-    long          m_oldItemIndex;
-    int           m_col;
-    bool          m_cancelled;
-    wxPoint       m_pointDrag;
-    wxListItem    m_item;
-};
-
-
-
-
-class wxListCtrl : public wxControl {
-public:
-    wxListCtrl(wxWindow* parent, wxWindowID id,
-               const wxPoint& pos = wxPyDefaultPosition,
-               const wxSize& size = wxPyDefaultSize,
-               long style = wxLC_ICON,
-               const wxValidator& validator = wxPyDefaultValidator,
-               char* name = "listCtrl");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
-    bool DeleteItem(long item);
-    bool DeleteAllItems();
-    bool DeleteColumn(int col);
-    bool DeleteAllColumns(void);
-    void ClearAll(void);
-#ifdef __WXMSW__
-    wxTextCtrl* EditLabel(long item);
-    bool EndEditLabel(bool cancel);
-    wxTextCtrl* GetEditControl();
-#endif
-    bool EnsureVisible(long item);
-    long FindItem(long start, const wxString& str, bool partial = FALSE);
-    %name(FindItemData)long FindItem(long start, long data);
-    %name(FindItemAtPos)long FindItem(long start, const wxPoint& pt,
-                                      int direction);
-    bool GetColumn(int col, wxListItem& item);
-    int GetColumnWidth(int col);
-    int GetCountPerPage();
-    wxImageList* GetImageList(int which);
-    long GetItemData(long item);
-
-    %addmethods {
-        %new wxListItem* GetItem() {
-            wxListItem* info = new wxListItem;
-            self->GetItem(*info);
-            return info;
-        }
-        %new wxPoint* GetItemPosition(long item) {
-            wxPoint* pos = new wxPoint;
-            self->GetItemPosition(item, *pos);
-            return pos;
-        }
-        %new wxRect* GetItemRect(long item, int code = wxLIST_RECT_BOUNDS) {
-            wxRect* rect= new wxRect;
-            self->GetItemRect(item, *rect, code);
-            return rect;
-        }
-    }
-
-    int GetItemState(long item, long stateMask);
-    int GetItemCount();
-    int GetItemSpacing(bool isSmall);
-    wxString GetItemText(long item);
-    long GetNextItem(long item,
-                     int geometry = wxLIST_NEXT_ALL,
-                     int state = wxLIST_STATE_DONTCARE);
-    int GetSelectedItemCount();
-#ifdef __WXMSW__
-    wxColour GetTextColour();
-    void SetTextColour(const wxColour& col);
-#endif
-    long GetTopItem();
-    long HitTest(const wxPoint& point, int& OUTPUT);
-    %name(InsertColumnWithInfo)long InsertColumn(long col, wxListItem& info);
-    long InsertColumn(long col, const wxString& heading,
-                      int format = wxLIST_FORMAT_LEFT,
-                      int width = -1);
-
-    long InsertItem(wxListItem& info);
-    %name(InsertStringItem)     long InsertItem(long index, const wxString& label);
-    %name(InsertImageItem)      long InsertItem(long index, int imageIndex);
-    %name(InsertImageStringItem)long InsertItem(long index, const wxString& label,
-                                                int imageIndex);
-
-    bool ScrollList(int dx, int dy);
-    void SetBackgroundColour(const wxColour& col);
-    bool SetColumn(int col, wxListItem& item);
-    bool SetColumnWidth(int col, int width);
-    void SetImageList(wxImageList* imageList, int which);
-    bool SetItem(wxListItem& info);
-    %name(SetItemString)long SetItem(long index, int col, const wxString& label,
-                                     int imageId = -1);
-    bool SetItemData(long item, long data);
-    bool SetItemImage(long item, int image, int selImage);
-    bool SetItemPosition(long item, const wxPoint& pos);
-    bool SetItemState(long item, long state, long stateMask);
-    void SetItemText(long item, const wxString& text);
-    void SetSingleStyle(long style, bool add = TRUE);
-    void SetWindowStyleFlag(long style);
-    // TODO:  bool SortItems(wxListCtrlCompare fn, long data);
-};
-
-
-
-//----------------------------------------------------------------------
-
-
-class wxTreeItemId {
-public:
-    wxTreeItemId();
-    ~wxTreeItemId();
-    bool IsOk() const { return m_itemId != 0; }
-
-//    %addmethods {
-//        long GetId() { return (long)(*self); }
-//    }
-};
-
-
-
-// ****  This isn't very useful yet.  This needs to be specialized to enable
-// derived Python classes...
-class wxTreeItemData {
-public:
-    wxTreeItemData();
-    ~wxTreeItemData();
-
-    const wxTreeItemId& GetId();
-    void SetId(const wxTreeItemId& id);
-};
-
-
-
-
-class wxTreeEvent : public wxCommandEvent {
-public:
-    wxTreeItemId GetItem();
-    wxTreeItemId GetOldItem();
-    wxPoint GetPoint();
-    int GetCode();
-    void Veto();
-};
-
-
-// These are for the GetFirstChild/GetNextChild methods below
-%typemap(python, in)     long& INOUT = long* INOUT;
-%typemap(python, argout) long& INOUT = long* INOUT;
-
-
-class wxTreeCtrl : public wxControl {
-public:
-    wxTreeCtrl(wxWindow *parent, wxWindowID id = -1,
-               const wxPoint& pos = wxPyDefaultPosition,
-               const wxSize& size = wxPyDefaultSize,
-               long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
-               const wxValidator& validator = wxPyDefaultValidator,
-               char* name = "wxTreeCtrl");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    size_t GetCount();
-    unsigned int GetIndent();
-    void SetIndent(unsigned int indent);
-    wxImageList *GetImageList();
-    wxImageList *GetStateImageList();
-    void SetImageList(wxImageList *imageList);
-    void SetStateImageList(wxImageList *imageList);
-
-    wxString GetItemText(const wxTreeItemId& item);
-    int GetItemImage(const wxTreeItemId& item);
-    int GetItemSelectedImage(const wxTreeItemId& item);
-    wxTreeItemData *GetItemData(const wxTreeItemId& item);
-
-    void SetItemText(const wxTreeItemId& item, const wxString& text);
-    void SetItemImage(const wxTreeItemId& item, int image);
-    void SetItemSelectedImage(const wxTreeItemId& item, int image);
-    void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
-    void SetItemHasChildren(const wxTreeItemId& item, bool hasChildren = TRUE);
-
-    bool IsVisible(const wxTreeItemId& item);
-    bool ItemHasChildren(const wxTreeItemId& item);
-    bool IsExpanded(const wxTreeItemId& item);
-    bool IsSelected(const wxTreeItemId& item);
-
-    wxTreeItemId GetRootItem();
-    wxTreeItemId GetSelection();
-    wxTreeItemId GetParent(const wxTreeItemId& item);
-
-    wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& INOUT);
-    wxTreeItemId GetNextChild(const wxTreeItemId& item, long& INOUT);
-    wxTreeItemId GetNextSibling(const wxTreeItemId& item);
-    wxTreeItemId GetPrevSibling(const wxTreeItemId& item);
-    wxTreeItemId GetFirstVisibleItem();
-    wxTreeItemId GetNextVisible(const wxTreeItemId& item);
-    wxTreeItemId GetPrevVisible(const wxTreeItemId& item);
-
-
-    wxTreeItemId AddRoot(const wxString& text,
-                         int image = -1, int selectedImage = -1,
-                         wxTreeItemData *data = NULL);
-    wxTreeItemId PrependItem(const wxTreeItemId& parent,
-                             const wxString& text,
-                             int image = -1, int selectedImage = -1,
-                             wxTreeItemData *data = NULL);
-    wxTreeItemId InsertItem(const wxTreeItemId& parent,
-                            const wxTreeItemId& idPrevious,
-                            const wxString& text,
-                            int image = -1, int selectedImage = -1,
-                            wxTreeItemData *data = NULL);
-    wxTreeItemId AppendItem(const wxTreeItemId& parent,
-                            const wxString& text,
-                            int image = -1, int selectedImage = -1,
-                            wxTreeItemData *data = NULL);
-
-    void Delete(const wxTreeItemId& item);
-    void DeleteChildren(const wxTreeItemId& item);
-    void DeleteAllItems();
-
-    void Expand(const wxTreeItemId& item);
-    void Collapse(const wxTreeItemId& item);
-    void CollapseAndReset(const wxTreeItemId& item);
-    void Toggle(const wxTreeItemId& item);
-
-    void Unselect();
-    void SelectItem(const wxTreeItemId& item);
-    void EnsureVisible(const wxTreeItemId& item);
-    void ScrollTo(const wxTreeItemId& item);
-
-    wxTextCtrl* EditLabel(const wxTreeItemId& item);
-                          // **** figure out how to do this
-                          // wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
-    wxTextCtrl* GetEditControl();
-    void EndEditLabel(const wxTreeItemId& item, bool discardChanges = FALSE);
-
-//    void SortChildren(const wxTreeItemId& item);
-                      // **** And this too
-                      // wxTreeItemCmpFunc *cmpFunction = NULL);
-
-    void SetItemBold(const wxTreeItemId& item, bool bold = TRUE);
-    bool IsBold(const wxTreeItemId& item) const;
-    wxTreeItemId HitTest(const wxPoint& point);
-};
-
-
-//----------------------------------------------------------------------
-
-#ifdef SKIPTHIS
-#ifdef __WXMSW__
-class wxTabEvent : public wxCommandEvent {
-public:
-};
-
-
-
-class wxTabCtrl : public wxControl {
-public:
-    wxTabCtrl(wxWindow* parent, wxWindowID id,
-              const wxPoint& pos = wxPyDefaultPosition,
-              const wxSize& size = wxPyDefaultSize,
-              long style = 0,
-              char* name = "tabCtrl");
-
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-
-    bool DeleteAllItems();
-    bool DeleteItem(int item);
-    wxImageList* GetImageList();
-    int GetItemCount();
-    // TODO: void* GetItemData();
-    int GetItemImage(int item);
-
-    %addmethods {
-        %new wxRect* GetItemRect(int item) {
-            wxRect* rect = new wxRect;
-            self->GetItemRect(item, *rect);
-            return rect;
-        }
-    }
-
-    wxString GetItemText(int item);
-    bool GetRowCount();
-    int GetSelection();
-    int HitTest(const wxPoint& pt, long& OUTPUT);
-    void InsertItem(int item, const wxString& text,
-                    int imageId = -1, void* clientData = NULL);
-    // TODO: bool SetItemData(int item, void* data);
-    bool SetItemImage(int item, int image);
-    void SetImageList(wxImageList* imageList);
-    void SetItemSize(const wxSize& size);
-    bool SetItemText(int item, const wxString& text);
-    void SetPadding(const wxSize& padding);
-    int SetSelection(int item);
-
-};
-
-#endif
-#endif
-
-//----------------------------------------------------------------------
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.14  1999/01/30 07:30:10  RD
-// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-//
-// Various cleanup, tweaks, minor additions, etc. to maintain
-// compatibility with the current wxWindows.
-//
-// Revision 1.13  1998/12/17 14:07:34  RR
-//
-//   Removed minor differences between wxMSW and wxGTK
-//
-// Revision 1.12  1998/12/16 22:10:52  RD
-//
-// Tweaks needed to be able to build wxPython with wxGTK.
-//
-// Revision 1.11  1998/12/15 20:41:16  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.10  1998/11/25 08:45:23  RD
-//
-// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
-// Added events for wxGrid
-// Other various fixes and additions
-//
-// Revision 1.9  1998/11/16 00:00:54  RD
-// Generic treectrl for wxPython/GTK compiles...
-//
-// Revision 1.8  1998/11/11 04:40:20  RD
-// wxTreeCtrl now works (sort of) for wxPython-GTK.  This is the new
-// TreeCtrl in src/gtk/treectrl.cpp not the old generic one.
-//
-// Revision 1.7  1998/11/11 03:12:25  RD
-//
-// Additions for wxTreeCtrl
-//
-// Revision 1.6  1998/10/20 06:43:55  RD
-// New wxTreeCtrl wrappers (untested)
-// some changes in helpers
-// etc.
-//
-// Revision 1.5  1998/10/07 07:34:33  RD
-// Version 0.4.1 for wxGTK
-//
-// Revision 1.4  1998/10/02 06:40:36  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.3  1998/08/18 19:48:15  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.2  1998/08/15 07:36:30  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.1  1998/08/09 08:25:49  RD
-// Initial version
-//
-//

utils/wxPython/src/events.i

@@ -1,341 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        events.i
-// Purpose:     SWIGgable Event classes for wxPython
-//
-// Author:      Robin Dunn
-//
-// Created:     5/24/98
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module events
-
-%{
-#include "helpers.h"
-#include <wx/spinbutt.h>
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-%import misc.i
-
-//---------------------------------------------------------------------------
-
-class wxEvent {
-public:
-    wxObject* GetEventObject();
-    wxEventType GetEventType();
-    int GetId();
-    bool GetSkipped();
-    long GetTimestamp();
-    void SetEventObject(wxObject* object);
-    void SetEventType(wxEventType typ);
-    void SetId(int id);
-    void SetTimestamp(long timeStamp);
-    void Skip(bool skip = TRUE);
-};
-
-//---------------------------------------------------------------------------
-
-class wxSizeEvent : public wxEvent {
-public:
-    wxSize GetSize();
-};
-
-//---------------------------------------------------------------------------
-
-class wxCloseEvent : public wxEvent {
-public:
-    bool CanVeto();
-// ****    bool GetSessionEnding();
-    bool GetLoggingOff();
-    void Veto(bool veto = TRUE);
-    bool GetVeto();
-    void SetForce(bool force);
-    void SetCanVeto(bool canVeto);
-    void SetLoggingOff(bool loggingOff);
-    bool GetForce();
-};
-
-//---------------------------------------------------------------------------
-
-class wxCommandEvent : public wxEvent {
-public:
-    bool Checked();
-    long GetExtraLong();
-    int GetInt();
-    int GetSelection();
-    char* GetString();
-    bool IsSelection();
-
-};
-
-
-//---------------------------------------------------------------------------
-
-class wxScrollEvent: public wxCommandEvent {
-public:
-    int GetOrientation();
-    int GetPosition();
-};
-
-//---------------------------------------------------------------------------
-
-class wxSpinEvent : public wxScrollEvent {
-public:
-
-};
-
-//---------------------------------------------------------------------------
-
-class wxMouseEvent: public wxEvent {
-public:
-    bool IsButton();
-    bool ButtonDown(int but = -1);
-    bool ButtonDClick(int but = -1);
-    bool ButtonUp(int but = -1);
-    bool Button(int but);
-    bool ButtonIsDown(int but);
-    bool ControlDown();
-    bool MetaDown();
-    bool AltDown();
-    bool ShiftDown();
-    bool LeftDown();
-    bool MiddleDown();
-    bool RightDown();
-    bool LeftUp();
-    bool MiddleUp();
-    bool RightUp();
-    bool LeftDClick();
-    bool MiddleDClick();
-    bool RightDClick();
-    bool LeftIsDown();
-    bool MiddleIsDown();
-    bool RightIsDown();
-    bool Dragging();
-    bool Moving();
-    bool Entering();
-    bool Leaving();
-    void Position(long *OUTPUT, long *OUTPUT);
-    wxPoint GetPosition();
-    wxPoint GetLogicalPosition(const wxDC& dc);
-    long GetX();
-    long GetY();
-};
-
-//---------------------------------------------------------------------------
-
-class wxKeyEvent: public wxEvent {
-public:
-    bool ControlDown();
-    bool MetaDown();
-    bool AltDown();
-    bool ShiftDown();
-    long KeyCode();
-    void Position(float *OUTPUT, float *OUTPUT);
-    float GetX();
-    float GetY();
-};
-
-//---------------------------------------------------------------------------
-
-class wxMoveEvent: public wxEvent {
-public:
-    wxPoint GetPosition();
-};
-
-//---------------------------------------------------------------------------
-
-class wxPaintEvent: public wxEvent {
-public:
-
-};
-
-//---------------------------------------------------------------------------
-
-class wxEraseEvent: public wxEvent {
-public:
-    wxDC *GetDC();
-};
-
-//---------------------------------------------------------------------------
-
-class wxFocusEvent: public wxEvent {
-public:
-
-};
-
-//---------------------------------------------------------------------------
-
-class wxActivateEvent: public wxEvent{
-public:
-    bool GetActive();
-};
-
-//---------------------------------------------------------------------------
-
-class wxInitDialogEvent: public wxEvent {
-public:
-
-};
-
-//---------------------------------------------------------------------------
-
-class wxMenuEvent: public wxEvent {
-public:
-    int GetMenuId();
-};
-
-//---------------------------------------------------------------------------
-
-class wxShowEvent: public wxEvent {
-public:
-    void SetShow(bool show);
-    bool GetShow();
-};
-
-//---------------------------------------------------------------------------
-
-class wxIconizeEvent: public wxEvent {
-public:
-};
-
-//---------------------------------------------------------------------------
-
-class wxMaximizeEvent: public wxEvent {
-public:
-
-};
-
-//---------------------------------------------------------------------------
-
-class wxJoystickEvent: public wxEvent {
-public:
-    wxPoint GetPosition();
-    int GetZPosition();
-    int GetButtonState();
-    int GetButtonChange();
-    int GetJoystick();
-    void SetJoystick(int stick);
-    void SetButtonState(int state);
-    void SetButtonChange(int change);
-    void SetPosition(const wxPoint& pos);
-    void SetZPosition(int zPos);
-    bool IsButton();
-    bool IsMove();
-    bool IsZMove();
-    bool ButtonDown(int but = wxJOY_BUTTON_ANY);
-    bool ButtonUp(int but = wxJOY_BUTTON_ANY);
-    bool ButtonIsDown(int but =  wxJOY_BUTTON_ANY);
-};
-
-//---------------------------------------------------------------------------
-
-class wxDropFilesEvent: public wxEvent {
-public:
-    wxPoint GetPosition();
-    int GetNumberOfFiles();
-
-    %addmethods {
-        PyObject* GetFiles() {
-            int         count = self->GetNumberOfFiles();
-            wxString*   files = self->GetFiles();
-            PyObject*   list  = PyList_New(count);
-
-            if (!list) {
-                PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
-                return NULL;
-            }
-
-            for (int i=0; i<count; i++) {
-                PyList_SetItem(list, i, PyString_FromString((const char*)files[i]));
-            }
-            return list;
-        }
-    }
-};
-
-//---------------------------------------------------------------------------
-
-class wxIdleEvent: public wxEvent {
-public:
-    void RequestMore(bool needMore = TRUE);
-    bool MoreRequested();
-};
-
-//---------------------------------------------------------------------------
-
-class wxUpdateUIEvent: public wxEvent {
-public:
-    bool GetChecked();
-    bool GetEnabled();
-    wxString GetText();
-    bool GetSetText();
-    bool GetSetChecked();
-    bool GetSetEnabled();
-
-    void Check(bool check);
-    void Enable(bool enable);
-    void SetText(const wxString& text);
-};
-
-//---------------------------------------------------------------------------
-
-class wxSysColourChangedEvent: public wxEvent {
-public:
-
-};
-
-//---------------------------------------------------------------------------
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.5  1998/12/15 20:41:17  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.4  1998/11/16 00:00:55  RD
-// Generic treectrl for wxPython/GTK compiles...
-//
-// Revision 1.3  1998/10/20 06:43:56  RD
-// New wxTreeCtrl wrappers (untested)
-// some changes in helpers
-// etc.
-//
-// Revision 1.2  1998/08/15 07:36:33  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.1  1998/08/09 08:25:50  RD
-// Initial version
-//
-//
-

utils/wxPython/src/frames.i

@@ -1,122 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        frames.i
-// Purpose:     SWIG definitions of various window classes
-//
-// Author:      Robin Dunn
-//
-// Created:     8/27/98
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module frames
-
-%{
-#include "helpers.h"
-#include <wx/minifram.h>
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-%import misc.i
-%import gdi.i
-%import windows.i
-%import stattool.i
-
-%pragma(python) code = "import wx"
-
-//----------------------------------------------------------------------
-
-class wxFrame : public wxWindow {
-public:
-    wxFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
-            const wxPoint& pos = wxPyDefaultPosition,
-            const wxSize& size = wxPyDefaultSize,
-            long style = wxDEFAULT_FRAME_STYLE,
-            char* name = "frame");
-
-    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
-
-    void Centre(int direction = wxBOTH);
-#ifdef __WXMSW__
-    void Command(int id);
-#endif
-    wxStatusBar* CreateStatusBar(int number = 1,
-                                 long style = wxST_SIZEGRIP,
-                                 wxWindowID id = -1,
-                                 char* name = "statusBar");
-    wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL|wxTB_FLAT,
-                             wxWindowID id = -1,
-                             char* name = "toolBar");
-
-    wxMenuBar* GetMenuBar();
-    wxStatusBar* GetStatusBar();
-    wxString GetTitle();
-    wxToolBar* GetToolBar();
-    void Iconize(bool iconize);
-    bool IsIconized();
-    void Maximize(bool maximize);
-    void SetAcceleratorTable(const wxAcceleratorTable& accel);
-    void SetIcon(const wxIcon& icon);
-    void SetMenuBar(wxMenuBar* menuBar);
-    void SetStatusBar(wxStatusBar *statusBar);
-    void SetStatusText(const wxString& text, int number = 0);
-    void SetStatusWidths(int LCOUNT, int* LIST); // uses typemap
-    void SetTitle(const wxString& title);
-    void SetToolBar(wxToolBar* toolbar);
-
-};
-
-//---------------------------------------------------------------------------
-
-class wxMiniFrame : public wxFrame {
-public:
-    wxMiniFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
-                const wxPoint& pos = wxPyDefaultPosition,
-                const wxSize& size = wxPyDefaultSize,
-                long style = wxDEFAULT_FRAME_STYLE,
-                char* name = "frame");
-
-    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
-};
-
-
-//---------------------------------------------------------------------------
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.4  1998/12/16 22:10:53  RD
-// Tweaks needed to be able to build wxPython with wxGTK.
-//
-// Revision 1.3  1998/12/15 20:41:18  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-
-
-
-
-
-

utils/wxPython/src/gdi.i

@@ -1,582 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        gdi.i
-// Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
-//
-// Author:      Robin Dunn
-//
-// Created:     7/7/97
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module gdi
-
-%{
-#include "helpers.h"
-#include <wx/metafile.h>
-#ifndef __WXMSW__
-#include <wx/dcps.h>
-#endif
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-%import misc.i
-
-//---------------------------------------------------------------------------
-
-class wxBitmap {
-public:
-    wxBitmap(const wxString& name, long type);
-    ~wxBitmap();
-
-#ifdef __WXMSW__
-    void Create(int width, int height, int depth = -1);
-#endif
-    int GetDepth();
-    int GetHeight();
-    wxPalette* GetPalette();
-    wxMask* GetMask();
-    int GetWidth();
-    bool LoadFile(const wxString& name, long flags);
-    bool Ok();
-    bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
-    void SetDepth(int depth);
-    void SetHeight(int height);
-    void SetMask(wxMask* mask);
-#ifdef __WXMSW__
-    void SetPalette(wxPalette& palette);
-#endif
-    void SetWidth(int width);
-};
-
-%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
-wxBitmap* wxNoRefBitmap(char* name, long flags);
-
-%{                              // Alternate 'constructor'
-    wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
-        return new wxBitmap(width, height, depth);
-    }
-
-                                // This one won't own the reference, so Python won't call
-                                // the dtor, this is good for toolbars and such where
-                                // the parent will manage the bitmap.
-    wxBitmap* wxNoRefBitmap(char* name, long flags) {
-        return new wxBitmap(name, flags);
-    }
-%}
-
-//---------------------------------------------------------------------------
-
-class wxMask {
-public:
-    wxMask(const wxBitmap& bitmap);
-    ~wxMask();
-};
-
-%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
-%{
-    wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
-        return new wxMask(bitmap, colour);
-    }
-%}
-
-
-//---------------------------------------------------------------------------
-
-
-class wxIcon : public wxBitmap {
-public:
-#ifdef __WXMSW__
-    wxIcon(const wxString& name, long flags,
-           int desiredWidth = -1, int desiredHeight = -1);
-#endif
-    ~wxIcon();
-
-    int GetDepth();
-    int GetHeight();
-    int GetWidth();
-    bool LoadFile(const wxString& name, long flags);
-    bool Ok();
-    void SetDepth(int depth);
-    void SetHeight(int height);
-    void SetWidth(int width);
-};
-
-//---------------------------------------------------------------------------
-
-class wxCursor : public wxBitmap {
-public:
-#ifdef __WXMSW__
-    wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
-#endif
-    ~wxCursor();
-    bool Ok();
-};
-
-%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
-%{                              // Alternate 'constructor'
-    wxCursor* wxPyStockCursor(int id) {
-        return new wxCursor(id);
-    }
-%}
-
-//----------------------------------------------------------------------
-
-class wxFont {
-public:
-    // I'll do it this way to use long-lived objects and not have to
-    // worry about when python may delete the object.
-    %addmethods {
-        wxFont( int pointSize, int family, int style, int weight,
-                int underline=FALSE, char* faceName = "") {
-
-            return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
-                                                   underline, faceName);
-        }
-        // NO Destructor.
-    }
-
-
-    wxString GetFaceName();
-    int GetFamily();
-#ifdef __WXMSW__
-    int GetFontId();
-#endif
-    int GetPointSize();
-    int GetStyle();
-    bool GetUnderlined();
-    int GetWeight();
-    void SetFaceName(const wxString& faceName);
-    void SetFamily(int family);
-    void SetPointSize(int pointSize);
-    void SetStyle(int style);
-    void SetUnderlined(bool underlined);
-    void SetWeight(int weight);
-};
-
-//----------------------------------------------------------------------
-
-class wxColour {
-public:
-    wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
-    ~wxColour();
-    unsigned char Red();
-    unsigned char Green();
-    unsigned char Blue();
-    bool Ok();
-    void Set(unsigned char red, unsigned char green, unsigned char blue);
-    %addmethods {
-        PyObject* Get() {
-            PyObject* rv = PyTuple_New(3);
-            PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
-            PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
-            PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
-            return rv;
-        }
-    }
-};
-
-%new wxColour* wxNamedColour(const wxString& colorName);
-%{                                      // Alternate 'constructor'
-    wxColour* wxNamedColour(const wxString& colorName) {
-        return new wxColour(colorName);
-    }
-%}
-
-
-//----------------------------------------------------------------------
-
-typedef unsigned long wxDash;
-
-class wxPen {
-public:
-    // I'll do it this way to use long-lived objects and not have to
-    // worry about when python may delete the object.
-    %addmethods {
-        wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
-            return wxThePenList->FindOrCreatePen(*colour, width, style);
-        }
-        // NO Destructor.
-    }
-
-    int GetCap();
-    wxColour& GetColour();
-
-    int GetJoin();
-    int GetStyle();
-    int GetWidth();
-    bool Ok();
-    void SetCap(int cap_style);
-    void SetColour(wxColour& colour);
-    void SetJoin(int join_style);
-    void SetStyle(int style);
-    void SetWidth(int width);
-
-#ifdef __WXMSW__
-            // **** This one needs to return a list of ints (wxDash)
-    int GetDashes(wxDash **dashes);
-    wxBitmap* GetStipple();
-    void SetDashes(int LCOUNT, wxDash* LIST);
-    void SetStipple(wxBitmap& stipple);
-#endif
-};
-
-//----------------------------------------------------------------------
-
-class wxBrush {
-public:
-    // I'll do it this way to use long-lived objects and not have to
-    // worry about when python may delete the object.
-    %addmethods {
-        wxBrush(wxColour* colour, int style=wxSOLID) {
-            return wxTheBrushList->FindOrCreateBrush(*colour, style);
-        }
-        // NO Destructor.
-    }
-
-    wxColour& GetColour();
-    wxBitmap * GetStipple();
-    int GetStyle();
-    bool Ok();
-    void SetColour(wxColour &colour);
-    void SetStipple(wxBitmap& bitmap);
-    void SetStyle(int style);
-};
-
-//----------------------------------------------------------------------
-
-
-
-class wxDC {
-public:
-//    wxDC(); **** abstract base class, can't instantiate.
-    ~wxDC();
-
-    void BeginDrawing();
-    bool Blit(long xdest, long ydest, long width, long height,
-                wxDC *source, long xsrc, long ysrc, long logical_func);
-    void Clear();
-    void CrossHair(long x, long y);
-    void DestroyClippingRegion();
-    long DeviceToLogicalX(long x);
-    long DeviceToLogicalXRel(long x);
-    long DeviceToLogicalY(long y);
-    long DeviceToLogicalYRel(long y);
-    void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
-    void DrawEllipse(long x, long y, long width, long height);
-    void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
-    void DrawIcon(const wxIcon& icon, long x, long y);
-    void DrawLine(long x1, long y1, long x2, long y2);
-    void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
-    void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
-                     int fill_style=wxODDEVEN_RULE);
-    void DrawPoint(long x, long y);
-    void DrawRectangle(long x, long y, long width, long height);
-    void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
-    void DrawSpline(int LCOUNT, wxPoint* LIST);
-    void DrawText(const wxString& text, long x, long y);
-    void EndDoc();
-    void EndDrawing();
-    void EndPage();
-    void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
-    wxBrush&  GetBackground();
-    wxBrush&  GetBrush();
-    long GetCharHeight();
-    long GetCharWidth();
-    void GetClippingBox(long *OUTPUT, long *OUTPUT,
-                        long *OUTPUT, long *OUTPUT);
-    wxFont& GetFont();
-    int GetLogicalFunction();
-    int GetMapMode();
-    bool GetOptimization();
-    wxPen& GetPen();
-    %addmethods {
-        %new wxColour* GetPixel(long x, long y) {
-            wxColour* wc = new wxColour();
-            self->GetPixel(x, y, wc);
-            return wc;
-        }
-    }
-    void GetSize(int* OUTPUT, int* OUTPUT); //void GetSize(long* OUTPUT, long* OUTPUT);
-    wxColour& GetTextBackground();
-    void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT,
-                       long *OUTPUT, long *OUTPUT);
-    wxColour& GetTextForeground();
-    long LogicalToDeviceX(long x);
-    long LogicalToDeviceXRel(long x);
-    long LogicalToDeviceY(long y);
-    long LogicalToDeviceYRel(long y);
-    long MaxX();
-    long MaxY();
-    long MinX();
-    long MinY();
-    bool Ok();
-    void SetDeviceOrigin(long x, long y);
-    void SetBackground(const wxBrush& brush);
-    void SetBackgroundMode(int mode);
-    void SetClippingRegion(long x, long y, long width, long height);
-    void SetPalette(const wxPalette& colourMap);
-    void SetBrush(const wxBrush& brush);
-    void SetFont(const wxFont& font);
-    void SetLogicalFunction(int function);
-    void SetMapMode(int mode);
-    void SetOptimization(bool optimize);
-    void SetPen(const wxPen& pen);
-    void SetTextBackground(const wxColour& colour);
-    void SetTextForeground(const wxColour& colour);
-    void SetUserScale(double x_scale, double y_scale);
-    bool StartDoc(const wxString& message);
-    void StartPage();
-
-
-    %addmethods {
-            // This one is my own creation...
-        void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
-            wxMemoryDC* memDC = new wxMemoryDC;
-            memDC->SelectObject(bitmap);
-            if (swapPalette)
-                self->SetPalette(*bitmap.GetPalette());
-            self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
-                    0, 0, self->GetLogicalFunction());
-            memDC->SelectObject(wxNullBitmap);
-            delete memDC;
-        }
-    }
-};
-
-
-//----------------------------------------------------------------------
-
-class wxMemoryDC : public wxDC {
-public:
-    wxMemoryDC();
-
-    void SelectObject(const wxBitmap& bitmap);
-}
-
-%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
-%{                                      // Alternate 'constructor'
-    wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
-        return new wxMemoryDC(oldDC);
-    }
-%}
-
-
-//---------------------------------------------------------------------------
-
-class wxScreenDC : public wxDC {
-public:
-    wxScreenDC();
-
-    bool StartDrawingOnTop(wxWindow* window);
-    %name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
-    bool EndDrawingOnTop();
-};
-
-//---------------------------------------------------------------------------
-
-class wxClientDC : public wxDC {
-public:
-      wxClientDC(wxWindow* win);
-};
-
-//---------------------------------------------------------------------------
-
-class wxPaintDC : public wxDC {
-public:
-      wxPaintDC(wxWindow* win);
-};
-
-//---------------------------------------------------------------------------
-
-class wxWindowDC : public wxDC {
-public:
-      wxWindowDC(wxWindow* win);
-};
-
-//---------------------------------------------------------------------------
-
-#ifndef __WXMSW__
-class wxPostScriptDC : public wxDC {
-public:
-      wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
-};
-#endif
-
-//---------------------------------------------------------------------------
-
-#ifdef __WXMSW__
-class  wxPrinterDC : public wxDC {
-public:
-    wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
-                bool interactive = TRUE, int orientation = wxPORTRAIT);
-};
-#endif
-
-//---------------------------------------------------------------------------
-
-#ifdef __WXMSW__
-class wxMetaFileDC : public wxDC {
-public:
-    wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
-    wxMetaFile* Close();
-};
-#endif
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-
-%readonly
-extern wxFont *wxNORMAL_FONT;
-extern wxFont *wxSMALL_FONT;
-extern wxFont *wxITALIC_FONT;
-extern wxFont *wxSWISS_FONT;
-extern wxPen *wxRED_PEN;
-
-extern wxPen *wxCYAN_PEN;
-extern wxPen *wxGREEN_PEN;
-extern wxPen *wxBLACK_PEN;
-extern wxPen *wxWHITE_PEN;
-extern wxPen *wxTRANSPARENT_PEN;
-extern wxPen *wxBLACK_DASHED_PEN;
-extern wxPen *wxGREY_PEN;
-extern wxPen *wxMEDIUM_GREY_PEN;
-extern wxPen *wxLIGHT_GREY_PEN;
-
-extern wxBrush *wxBLUE_BRUSH;
-extern wxBrush *wxGREEN_BRUSH;
-extern wxBrush *wxWHITE_BRUSH;
-extern wxBrush *wxBLACK_BRUSH;
-extern wxBrush *wxTRANSPARENT_BRUSH;
-extern wxBrush *wxCYAN_BRUSH;
-extern wxBrush *wxRED_BRUSH;
-extern wxBrush *wxGREY_BRUSH;
-extern wxBrush *wxMEDIUM_GREY_BRUSH;
-extern wxBrush *wxLIGHT_GREY_BRUSH;
-
-extern wxColour *wxBLACK;
-extern wxColour *wxWHITE;
-extern wxColour *wxRED;
-extern wxColour *wxBLUE;
-extern wxColour *wxGREEN;
-extern wxColour *wxCYAN;
-extern wxColour *wxLIGHT_GREY;
-
-extern wxCursor *wxSTANDARD_CURSOR;
-extern wxCursor *wxHOURGLASS_CURSOR;
-extern wxCursor *wxCROSS_CURSOR;
-
-extern wxBitmap wxNullBitmap;
-extern wxIcon   wxNullIcon;
-extern wxCursor wxNullCursor;
-extern wxPen    wxNullPen;
-extern wxBrush  wxNullBrush;
-extern wxPalette wxNullPalette;
-extern wxFont   wxNullFont;
-extern wxColour wxNullColour;
-
-//---------------------------------------------------------------------------
-
-class wxPalette {
-public:
-    wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
-    ~wxPalette();
-
-    int GetPixel(byte red, byte green, byte blue);
-    bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
-    bool Ok();
-};
-
-//---------------------------------------------------------------------------
-
-
-//---------------------------------------------------------------------------
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.12  1999/01/30 07:30:11  RD
-// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-//
-// Various cleanup, tweaks, minor additions, etc. to maintain
-// compatibility with the current wxWindows.
-//
-// Revision 1.11  1998/12/18 15:49:05  RR
-//
-//   wxClipboard now serves the primary selection as well
-//   wxPython fixes
-//   warning mesages
-//
-// Revision 1.10  1998/12/17 18:05:50  RD
-//
-// wxPython 0.5.2
-// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
-// versions are much closer now!
-//
-// Revision 1.9  1998/12/17 14:07:37  RR
-//
-//   Removed minor differences between wxMSW and wxGTK
-//
-// Revision 1.8  1998/12/16 22:10:54  RD
-//
-// Tweaks needed to be able to build wxPython with wxGTK.
-//
-// Revision 1.7  1998/12/15 20:41:18  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.6  1998/11/25 08:45:24  RD
-//
-// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
-// Added events for wxGrid
-// Other various fixes and additions
-//
-// Revision 1.5  1998/10/20 06:43:57  RD
-// New wxTreeCtrl wrappers (untested)
-// some changes in helpers
-// etc.
-//
-// Revision 1.4  1998/10/02 06:40:38  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.3  1998/08/18 19:48:16  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.2  1998/08/15 07:36:35  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.1  1998/08/09 08:25:50  RD
-// Initial version
-//
-//

utils/wxPython/src/gtk/cmndlgs.py

@@ -1,592 +0,0 @@
-# This file was created automatically by SWIG.
-import cmndlgsc
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-import wx
-class wxColourDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxColourData(self.this)
-    def GetChooseFull(self):
-        val = cmndlgsc.wxColourData_GetChooseFull(self.this)
-        return val
-    def GetColour(self):
-        val = cmndlgsc.wxColourData_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetCustomColour(self,arg0):
-        val = cmndlgsc.wxColourData_GetCustomColour(self.this,arg0)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def SetChooseFull(self,arg0):
-        val = cmndlgsc.wxColourData_SetChooseFull(self.this,arg0)
-        return val
-    def SetColour(self,arg0):
-        val = cmndlgsc.wxColourData_SetColour(self.this,arg0.this)
-        return val
-    def SetCustomColour(self,arg0,arg1):
-        val = cmndlgsc.wxColourData_SetCustomColour(self.this,arg0,arg1.this)
-        return val
-    def __repr__(self):
-        return "<C wxColourData instance>"
-class wxColourData(wxColourDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxColourData()
-        self.thisown = 1
-
-
-
-
-class wxColourDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetColourData(self):
-        val = cmndlgsc.wxColourDialog_GetColourData(self.this)
-        val = wxColourDataPtr(val)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxColourDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxColourDialog instance>"
-class wxColourDialog(wxColourDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxColourDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxDirDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPath(self):
-        val = cmndlgsc.wxDirDialog_GetPath(self.this)
-        return val
-    def GetMessage(self):
-        val = cmndlgsc.wxDirDialog_GetMessage(self.this)
-        return val
-    def GetStyle(self):
-        val = cmndlgsc.wxDirDialog_GetStyle(self.this)
-        return val
-    def SetMessage(self,arg0):
-        val = cmndlgsc.wxDirDialog_SetMessage(self.this,arg0)
-        return val
-    def SetPath(self,arg0):
-        val = cmndlgsc.wxDirDialog_SetPath(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxDirDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxDirDialog instance>"
-class wxDirDialog(wxDirDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[3] = argl[3].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxDirDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxFileDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetDirectory(self):
-        val = cmndlgsc.wxFileDialog_GetDirectory(self.this)
-        return val
-    def GetFilename(self):
-        val = cmndlgsc.wxFileDialog_GetFilename(self.this)
-        return val
-    def GetFilterIndex(self):
-        val = cmndlgsc.wxFileDialog_GetFilterIndex(self.this)
-        return val
-    def GetMessage(self):
-        val = cmndlgsc.wxFileDialog_GetMessage(self.this)
-        return val
-    def GetPath(self):
-        val = cmndlgsc.wxFileDialog_GetPath(self.this)
-        return val
-    def GetStyle(self):
-        val = cmndlgsc.wxFileDialog_GetStyle(self.this)
-        return val
-    def GetWildcard(self):
-        val = cmndlgsc.wxFileDialog_GetWildcard(self.this)
-        return val
-    def SetDirectory(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetDirectory(self.this,arg0)
-        return val
-    def SetFilename(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetFilename(self.this,arg0)
-        return val
-    def SetFilterIndex(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetFilterIndex(self.this,arg0)
-        return val
-    def SetMessage(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetMessage(self.this,arg0)
-        return val
-    def SetPath(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetPath(self.this,arg0)
-        return val
-    def SetStyle(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetStyle(self.this,arg0)
-        return val
-    def SetWildcard(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetWildcard(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxFileDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxFileDialog instance>"
-class wxFileDialog(wxFileDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[5] = argl[5].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxFileDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxSingleChoiceDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSelection(self):
-        val = cmndlgsc.wxSingleChoiceDialog_GetSelection(self.this)
-        return val
-    def GetStringSelection(self):
-        val = cmndlgsc.wxSingleChoiceDialog_GetStringSelection(self.this)
-        return val
-    def SetSelection(self,arg0):
-        val = cmndlgsc.wxSingleChoiceDialog_SetSelection(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxSingleChoiceDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxSingleChoiceDialog instance>"
-class wxSingleChoiceDialog(wxSingleChoiceDialogPtr):
-    def __init__(self,arg0,arg1,arg2,arg3,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,(arg0.this,arg1,arg2,arg3,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxTextEntryDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetValue(self):
-        val = cmndlgsc.wxTextEntryDialog_GetValue(self.this)
-        return val
-    def SetValue(self,arg0):
-        val = cmndlgsc.wxTextEntryDialog_SetValue(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxTextEntryDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxTextEntryDialog instance>"
-class wxTextEntryDialog(wxTextEntryDialogPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[3] = argl[3].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxTextEntryDialog,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxFontDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxFontData(self.this)
-    def EnableEffects(self,arg0):
-        val = cmndlgsc.wxFontData_EnableEffects(self.this,arg0)
-        return val
-    def GetAllowSymbols(self):
-        val = cmndlgsc.wxFontData_GetAllowSymbols(self.this)
-        return val
-    def GetColour(self):
-        val = cmndlgsc.wxFontData_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetChosenFont(self):
-        val = cmndlgsc.wxFontData_GetChosenFont(self.this)
-        val = wxFontPtr(val)
-        val.thisown = 1
-        return val
-    def GetEnableEffects(self):
-        val = cmndlgsc.wxFontData_GetEnableEffects(self.this)
-        return val
-    def GetInitialFont(self):
-        val = cmndlgsc.wxFontData_GetInitialFont(self.this)
-        val = wxFontPtr(val)
-        val.thisown = 1
-        return val
-    def GetShowHelp(self):
-        val = cmndlgsc.wxFontData_GetShowHelp(self.this)
-        return val
-    def SetAllowSymbols(self,arg0):
-        val = cmndlgsc.wxFontData_SetAllowSymbols(self.this,arg0)
-        return val
-    def SetChosenFont(self,arg0):
-        val = cmndlgsc.wxFontData_SetChosenFont(self.this,arg0.this)
-        return val
-    def SetColour(self,arg0):
-        val = cmndlgsc.wxFontData_SetColour(self.this,arg0.this)
-        return val
-    def SetInitialFont(self,arg0):
-        val = cmndlgsc.wxFontData_SetInitialFont(self.this,arg0.this)
-        return val
-    def SetRange(self,arg0,arg1):
-        val = cmndlgsc.wxFontData_SetRange(self.this,arg0,arg1)
-        return val
-    def SetShowHelp(self,arg0):
-        val = cmndlgsc.wxFontData_SetShowHelp(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxFontData instance>"
-class wxFontData(wxFontDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxFontData()
-        self.thisown = 1
-
-
-
-
-class wxFontDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetFontData(self):
-        val = cmndlgsc.wxFontDialog_GetFontData(self.this)
-        val = wxFontDataPtr(val)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxFontDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxFontDialog instance>"
-class wxFontDialog(wxFontDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxFontDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxPageSetupDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxPageSetupData(self.this)
-    def EnableHelp(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnableHelp(self.this,arg0)
-        return val
-    def EnableMargins(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnableMargins(self.this,arg0)
-        return val
-    def EnableOrientation(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnableOrientation(self.this,arg0)
-        return val
-    def EnablePaper(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnablePaper(self.this,arg0)
-        return val
-    def EnablePrinter(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnablePrinter(self.this,arg0)
-        return val
-    def GetPaperSize(self):
-        val = cmndlgsc.wxPageSetupData_GetPaperSize(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMarginTopLeft(self):
-        val = cmndlgsc.wxPageSetupData_GetMarginTopLeft(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMarginBottomRight(self):
-        val = cmndlgsc.wxPageSetupData_GetMarginBottomRight(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMinMarginTopLeft(self):
-        val = cmndlgsc.wxPageSetupData_GetMinMarginTopLeft(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMinMarginBottomRight(self):
-        val = cmndlgsc.wxPageSetupData_GetMinMarginBottomRight(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetOrientation(self):
-        val = cmndlgsc.wxPageSetupData_GetOrientation(self.this)
-        return val
-    def GetDefaultMinMargins(self):
-        val = cmndlgsc.wxPageSetupData_GetDefaultMinMargins(self.this)
-        return val
-    def GetEnableMargins(self):
-        val = cmndlgsc.wxPageSetupData_GetEnableMargins(self.this)
-        return val
-    def GetEnableOrientation(self):
-        val = cmndlgsc.wxPageSetupData_GetEnableOrientation(self.this)
-        return val
-    def GetEnablePaper(self):
-        val = cmndlgsc.wxPageSetupData_GetEnablePaper(self.this)
-        return val
-    def GetEnablePrinter(self):
-        val = cmndlgsc.wxPageSetupData_GetEnablePrinter(self.this)
-        return val
-    def GetEnableHelp(self):
-        val = cmndlgsc.wxPageSetupData_GetEnableHelp(self.this)
-        return val
-    def GetDefaultInfo(self):
-        val = cmndlgsc.wxPageSetupData_GetDefaultInfo(self.this)
-        return val
-    def SetPaperSize(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetPaperSize(self.this,arg0.this)
-        return val
-    def SetMarginTopLeft(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMarginTopLeft(self.this,arg0.this)
-        return val
-    def SetMarginBottomRight(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMarginBottomRight(self.this,arg0.this)
-        return val
-    def SetMinMarginTopLeft(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMinMarginTopLeft(self.this,arg0.this)
-        return val
-    def SetMinMarginBottomRight(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMinMarginBottomRight(self.this,arg0.this)
-        return val
-    def SetOrientation(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetOrientation(self.this,arg0)
-        return val
-    def SetDefaultMinMargins(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetDefaultMinMargins(self.this,arg0)
-        return val
-    def SetDefaultInfo(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetDefaultInfo(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxPageSetupData instance>"
-class wxPageSetupData(wxPageSetupDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxPageSetupData()
-        self.thisown = 1
-
-
-
-
-class wxPageSetupDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPageSetupData(self):
-        val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this)
-        val = wxPageSetupDataPtr(val)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPageSetupDialog instance>"
-class wxPageSetupDialog(wxPageSetupDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxPageSetupDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxPrintDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxPrintData(self.this)
-    def EnableHelp(self,arg0):
-        val = cmndlgsc.wxPrintData_EnableHelp(self.this,arg0)
-        return val
-    def EnablePageNumbers(self,arg0):
-        val = cmndlgsc.wxPrintData_EnablePageNumbers(self.this,arg0)
-        return val
-    def EnablePrintToFile(self,arg0):
-        val = cmndlgsc.wxPrintData_EnablePrintToFile(self.this,arg0)
-        return val
-    def EnableSelection(self,arg0):
-        val = cmndlgsc.wxPrintData_EnableSelection(self.this,arg0)
-        return val
-    def GetAllPages(self):
-        val = cmndlgsc.wxPrintData_GetAllPages(self.this)
-        return val
-    def GetCollate(self):
-        val = cmndlgsc.wxPrintData_GetCollate(self.this)
-        return val
-    def GetFromPage(self):
-        val = cmndlgsc.wxPrintData_GetFromPage(self.this)
-        return val
-    def GetMaxPage(self):
-        val = cmndlgsc.wxPrintData_GetMaxPage(self.this)
-        return val
-    def GetMinPage(self):
-        val = cmndlgsc.wxPrintData_GetMinPage(self.this)
-        return val
-    def GetNoCopies(self):
-        val = cmndlgsc.wxPrintData_GetNoCopies(self.this)
-        return val
-    def GetOrientation(self):
-        val = cmndlgsc.wxPrintData_GetOrientation(self.this)
-        return val
-    def GetToPage(self):
-        val = cmndlgsc.wxPrintData_GetToPage(self.this)
-        return val
-    def SetCollate(self,arg0):
-        val = cmndlgsc.wxPrintData_SetCollate(self.this,arg0)
-        return val
-    def SetFromPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetFromPage(self.this,arg0)
-        return val
-    def SetMaxPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetMaxPage(self.this,arg0)
-        return val
-    def SetMinPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetMinPage(self.this,arg0)
-        return val
-    def SetOrientation(self,arg0):
-        val = cmndlgsc.wxPrintData_SetOrientation(self.this,arg0)
-        return val
-    def SetNoCopies(self,arg0):
-        val = cmndlgsc.wxPrintData_SetNoCopies(self.this,arg0)
-        return val
-    def SetPrintToFile(self,arg0):
-        val = cmndlgsc.wxPrintData_SetPrintToFile(self.this,arg0)
-        return val
-    def SetSetupDialog(self,arg0):
-        val = cmndlgsc.wxPrintData_SetSetupDialog(self.this,arg0)
-        return val
-    def SetToPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetToPage(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxPrintData instance>"
-class wxPrintData(wxPrintDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxPrintData()
-        self.thisown = 1
-
-
-
-
-class wxPrintDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPrintData(self):
-        val = cmndlgsc.wxPrintDialog_GetPrintData(self.this)
-        val = wxPrintDataPtr(val)
-        return val
-    def GetPrintDC(self):
-        val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this)
-        val = wxDCPtr(val)
-        val.thisown = 1
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxPrintDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPrintDialog instance>"
-class wxPrintDialog(wxPrintDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxPrintDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxMessageDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ShowModal(self):
-        val = cmndlgsc.wxMessageDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMessageDialog instance>"
-class wxMessageDialog(wxMessageDialogPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxMessageDialog,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/controls.py

@@ -1,836 +0,0 @@
-# This file was created automatically by SWIG.
-import controlsc
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from events import *
-import wx
-class wxControlPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Command(self,arg0):
-        val = controlsc.wxControl_Command(self.this,arg0.this)
-        return val
-    def GetLabel(self):
-        val = controlsc.wxControl_GetLabel(self.this)
-        return val
-    def SetLabel(self,arg0):
-        val = controlsc.wxControl_SetLabel(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxControl instance>"
-class wxControl(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxButtonPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetDefault(self):
-        val = controlsc.wxButton_SetDefault(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxButton instance>"
-class wxButton(wxButtonPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxButton,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxBitmapButtonPtr(wxButtonPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBitmapLabel(self):
-        val = controlsc.wxBitmapButton_GetBitmapLabel(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetBitmapDisabled(self):
-        val = controlsc.wxBitmapButton_GetBitmapDisabled(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetBitmapFocus(self):
-        val = controlsc.wxBitmapButton_GetBitmapFocus(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetBitmapSelected(self):
-        val = controlsc.wxBitmapButton_GetBitmapSelected(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def SetBitmapDisabled(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapDisabled(self.this,arg0.this)
-        return val
-    def SetBitmapFocus(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapFocus(self.this,arg0.this)
-        return val
-    def SetBitmapSelected(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapSelected(self.this,arg0.this)
-        return val
-    def SetBitmapLabel(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapLabel(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxBitmapButton instance>"
-class wxBitmapButton(wxBitmapButtonPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxBitmapButton,(arg0.this,arg1,arg2.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxCheckBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetValue(self):
-        val = controlsc.wxCheckBox_GetValue(self.this)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxCheckBox_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxCheckBox instance>"
-class wxCheckBox(wxCheckBoxPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxCheckBox,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxChoicePtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0):
-        val = controlsc.wxChoice_Append(self.this,arg0)
-        return val
-    def Clear(self):
-        val = controlsc.wxChoice_Clear(self.this)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxChoice_FindString(self.this,arg0)
-        return val
-    def GetColumns(self):
-        val = controlsc.wxChoice_GetColumns(self.this)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxChoice_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxChoice_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxChoice_GetStringSelection(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxChoice_Number(self.this)
-        return val
-    def SetColumns(self,*args):
-        val = apply(controlsc.wxChoice_SetColumns,(self.this,)+args)
-        return val
-    def SetSelection(self,arg0):
-        val = controlsc.wxChoice_SetSelection(self.this,arg0)
-        return val
-    def SetStringSelection(self,arg0):
-        val = controlsc.wxChoice_SetStringSelection(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxChoice instance>"
-class wxChoice(wxChoicePtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxChoice,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxComboBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0):
-        val = controlsc.wxComboBox_Append(self.this,arg0)
-        return val
-    def Clear(self):
-        val = controlsc.wxComboBox_Clear(self.this)
-        return val
-    def Copy(self):
-        val = controlsc.wxComboBox_Copy(self.this)
-        return val
-    def Cut(self):
-        val = controlsc.wxComboBox_Cut(self.this)
-        return val
-    def Delete(self,arg0):
-        val = controlsc.wxComboBox_Delete(self.this,arg0)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxComboBox_FindString(self.this,arg0)
-        return val
-    def GetInsertionPoint(self):
-        val = controlsc.wxComboBox_GetInsertionPoint(self.this)
-        return val
-    def GetLastPosition(self):
-        val = controlsc.wxComboBox_GetLastPosition(self.this)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxComboBox_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxComboBox_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxComboBox_GetStringSelection(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxComboBox_GetValue(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxComboBox_Number(self.this)
-        return val
-    def Paste(self):
-        val = controlsc.wxComboBox_Paste(self.this)
-        return val
-    def Replace(self,arg0,arg1,arg2):
-        val = controlsc.wxComboBox_Replace(self.this,arg0,arg1,arg2)
-        return val
-    def Remove(self,arg0,arg1):
-        val = controlsc.wxComboBox_Remove(self.this,arg0,arg1)
-        return val
-    def SetInsertionPoint(self,arg0):
-        val = controlsc.wxComboBox_SetInsertionPoint(self.this,arg0)
-        return val
-    def SetInsertionPointEnd(self):
-        val = controlsc.wxComboBox_SetInsertionPointEnd(self.this)
-        return val
-    def SetSelection(self,arg0,*args):
-        val = apply(controlsc.wxComboBox_SetSelection,(self.this,arg0,)+args)
-        return val
-    def SetMark(self,arg0,arg1):
-        val = controlsc.wxComboBox_SetMark(self.this,arg0,arg1)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxComboBox_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxComboBox instance>"
-class wxComboBox(wxComboBoxPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxComboBox,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxGaugePtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBezelFace(self):
-        val = controlsc.wxGauge_GetBezelFace(self.this)
-        return val
-    def GetRange(self):
-        val = controlsc.wxGauge_GetRange(self.this)
-        return val
-    def GetShadowWidth(self):
-        val = controlsc.wxGauge_GetShadowWidth(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxGauge_GetValue(self.this)
-        return val
-    def SetBezelFace(self,arg0):
-        val = controlsc.wxGauge_SetBezelFace(self.this,arg0)
-        return val
-    def SetRange(self,arg0):
-        val = controlsc.wxGauge_SetRange(self.this,arg0)
-        return val
-    def SetShadowWidth(self,arg0):
-        val = controlsc.wxGauge_SetShadowWidth(self.this,arg0)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxGauge_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxGauge instance>"
-class wxGauge(wxGaugePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxGauge,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxStaticBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxStaticBox instance>"
-class wxStaticBox(wxStaticBoxPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxStaticBox,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-
-
-
-
-class wxStaticTextPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetLabel(self):
-        val = controlsc.wxStaticText_GetLabel(self.this)
-        return val
-    def SetLabel(self,arg0):
-        val = controlsc.wxStaticText_SetLabel(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxStaticText instance>"
-class wxStaticText(wxStaticTextPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxStaticText,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxListBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0):
-        val = controlsc.wxListBox_Append(self.this,arg0)
-        return val
-    def Clear(self):
-        val = controlsc.wxListBox_Clear(self.this)
-        return val
-    def Delete(self,arg0):
-        val = controlsc.wxListBox_Delete(self.this,arg0)
-        return val
-    def Deselect(self,arg0):
-        val = controlsc.wxListBox_Deselect(self.this,arg0)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxListBox_FindString(self.this,arg0)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxListBox_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxListBox_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxListBox_GetStringSelection(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxListBox_Number(self.this)
-        return val
-    def Selected(self,arg0):
-        val = controlsc.wxListBox_Selected(self.this,arg0)
-        return val
-    def Set(self,arg0,*args):
-        val = apply(controlsc.wxListBox_Set,(self.this,arg0,)+args)
-        return val
-    def SetFirstItem(self,arg0):
-        val = controlsc.wxListBox_SetFirstItem(self.this,arg0)
-        return val
-    def SetFirstItemStr(self,arg0):
-        val = controlsc.wxListBox_SetFirstItemStr(self.this,arg0)
-        return val
-    def SetSelection(self,arg0,*args):
-        val = apply(controlsc.wxListBox_SetSelection,(self.this,arg0,)+args)
-        return val
-    def SetString(self,arg0,arg1):
-        val = controlsc.wxListBox_SetString(self.this,arg0,arg1)
-        return val
-    def SetStringSelection(self,arg0,*args):
-        val = apply(controlsc.wxListBox_SetStringSelection,(self.this,arg0,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxListBox instance>"
-class wxListBox(wxListBoxPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxListBox,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxCheckListBoxPtr(wxListBoxPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def IsChecked(self,arg0):
-        val = controlsc.wxCheckListBox_IsChecked(self.this,arg0)
-        return val
-    def Check(self,arg0,*args):
-        val = apply(controlsc.wxCheckListBox_Check,(self.this,arg0,)+args)
-        return val
-    def GetItemHeight(self):
-        val = controlsc.wxCheckListBox_GetItemHeight(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCheckListBox instance>"
-class wxCheckListBox(wxCheckListBoxPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxCheckListBox,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxTextCtrlPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Clear(self):
-        val = controlsc.wxTextCtrl_Clear(self.this)
-        return val
-    def Copy(self):
-        val = controlsc.wxTextCtrl_Copy(self.this)
-        return val
-    def Cut(self):
-        val = controlsc.wxTextCtrl_Cut(self.this)
-        return val
-    def DiscardEdits(self):
-        val = controlsc.wxTextCtrl_DiscardEdits(self.this)
-        return val
-    def GetInsertionPoint(self):
-        val = controlsc.wxTextCtrl_GetInsertionPoint(self.this)
-        return val
-    def GetLastPosition(self):
-        val = controlsc.wxTextCtrl_GetLastPosition(self.this)
-        return val
-    def GetLineLength(self,arg0):
-        val = controlsc.wxTextCtrl_GetLineLength(self.this,arg0)
-        return val
-    def GetLineText(self,arg0):
-        val = controlsc.wxTextCtrl_GetLineText(self.this,arg0)
-        return val
-    def GetNumberOfLines(self):
-        val = controlsc.wxTextCtrl_GetNumberOfLines(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxTextCtrl_GetValue(self.this)
-        return val
-    def IsModified(self):
-        val = controlsc.wxTextCtrl_IsModified(self.this)
-        return val
-    def LoadFile(self,arg0):
-        val = controlsc.wxTextCtrl_LoadFile(self.this,arg0)
-        return val
-    def Paste(self):
-        val = controlsc.wxTextCtrl_Paste(self.this)
-        return val
-    def PositionToXY(self,arg0):
-        val = controlsc.wxTextCtrl_PositionToXY(self.this,arg0)
-        return val
-    def Remove(self,arg0,arg1):
-        val = controlsc.wxTextCtrl_Remove(self.this,arg0,arg1)
-        return val
-    def Replace(self,arg0,arg1,arg2):
-        val = controlsc.wxTextCtrl_Replace(self.this,arg0,arg1,arg2)
-        return val
-    def SaveFile(self,arg0):
-        val = controlsc.wxTextCtrl_SaveFile(self.this,arg0)
-        return val
-    def SetEditable(self,arg0):
-        val = controlsc.wxTextCtrl_SetEditable(self.this,arg0)
-        return val
-    def SetInsertionPoint(self,arg0):
-        val = controlsc.wxTextCtrl_SetInsertionPoint(self.this,arg0)
-        return val
-    def SetInsertionPointEnd(self):
-        val = controlsc.wxTextCtrl_SetInsertionPointEnd(self.this)
-        return val
-    def SetSelection(self,arg0,arg1):
-        val = controlsc.wxTextCtrl_SetSelection(self.this,arg0,arg1)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxTextCtrl_SetValue(self.this,arg0)
-        return val
-    def ShowPosition(self,arg0):
-        val = controlsc.wxTextCtrl_ShowPosition(self.this,arg0)
-        return val
-    def WriteText(self,arg0):
-        val = controlsc.wxTextCtrl_WriteText(self.this,arg0)
-        return val
-    def XYToPosition(self,arg0,arg1):
-        val = controlsc.wxTextCtrl_XYToPosition(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxTextCtrl instance>"
-class wxTextCtrl(wxTextCtrlPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxTextCtrl,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxScrollBarPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetRange(self):
-        val = controlsc.wxScrollBar_GetRange(self.this)
-        return val
-    def GetPageSize(self):
-        val = controlsc.wxScrollBar_GetPageSize(self.this)
-        return val
-    def GetThumbPosition(self):
-        val = controlsc.wxScrollBar_GetThumbPosition(self.this)
-        return val
-    def GetThumbSize(self):
-        val = controlsc.wxScrollBar_GetThumbSize(self.this)
-        return val
-    def SetThumbPosition(self,arg0):
-        val = controlsc.wxScrollBar_SetThumbPosition(self.this,arg0)
-        return val
-    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(controlsc.wxScrollBar_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxScrollBar instance>"
-class wxScrollBar(wxScrollBarPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxScrollBar,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxSpinButtonPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetMax(self):
-        val = controlsc.wxSpinButton_GetMax(self.this)
-        return val
-    def GetMin(self):
-        val = controlsc.wxSpinButton_GetMin(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxSpinButton_GetValue(self.this)
-        return val
-    def SetRange(self,arg0,arg1):
-        val = controlsc.wxSpinButton_SetRange(self.this,arg0,arg1)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxSpinButton_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxSpinButton instance>"
-class wxSpinButton(wxSpinButtonPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxSpinButton,(arg0.this,)+args)
-        self.thisown = 1
-
-
-
-
-class wxStaticBitmapPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBitmap(self):
-        val = controlsc.wxStaticBitmap_GetBitmap(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def SetBitmap(self,arg0):
-        val = controlsc.wxStaticBitmap_SetBitmap(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxStaticBitmap instance>"
-class wxStaticBitmap(wxStaticBitmapPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxStaticBitmap,(arg0.this,arg1,arg2.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxRadioBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def EnableBox(self,arg0):
-        val = controlsc.wxRadioBox_EnableBox(self.this,arg0)
-        return val
-    def Enable(self,arg0,arg1):
-        val = controlsc.wxRadioBox_Enable(self.this,arg0,arg1)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxRadioBox_FindString(self.this,arg0)
-        return val
-    def GetLabel(self,arg0):
-        val = controlsc.wxRadioBox_GetLabel(self.this,arg0)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxRadioBox_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxRadioBox_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxRadioBox_GetStringSelection(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxRadioBox_Number(self.this)
-        return val
-    def SetBoxLabel(self,arg0):
-        val = controlsc.wxRadioBox_SetBoxLabel(self.this,arg0)
-        return val
-    def SetLabel(self,arg0,arg1):
-        val = controlsc.wxRadioBox_SetLabel(self.this,arg0,arg1)
-        return val
-    def SetSelection(self,arg0):
-        val = controlsc.wxRadioBox_SetSelection(self.this,arg0)
-        return val
-    def SetStringSelection(self,arg0):
-        val = controlsc.wxRadioBox_SetStringSelection(self.this,arg0)
-        return val
-    def Show(self,arg0):
-        val = controlsc.wxRadioBox_Show(self.this,arg0)
-        return val
-    def ShowItem(self,arg0,arg1):
-        val = controlsc.wxRadioBox_ShowItem(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxRadioBox instance>"
-class wxRadioBox(wxRadioBoxPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxRadioBox,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxRadioButtonPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetValue(self):
-        val = controlsc.wxRadioButton_GetValue(self.this)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxRadioButton_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxRadioButton instance>"
-class wxRadioButton(wxRadioButtonPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxRadioButton,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxSliderPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ClearSel(self):
-        val = controlsc.wxSlider_ClearSel(self.this)
-        return val
-    def ClearTicks(self):
-        val = controlsc.wxSlider_ClearTicks(self.this)
-        return val
-    def GetLineSize(self):
-        val = controlsc.wxSlider_GetLineSize(self.this)
-        return val
-    def GetMax(self):
-        val = controlsc.wxSlider_GetMax(self.this)
-        return val
-    def GetMin(self):
-        val = controlsc.wxSlider_GetMin(self.this)
-        return val
-    def GetPageSize(self):
-        val = controlsc.wxSlider_GetPageSize(self.this)
-        return val
-    def GetSelEnd(self):
-        val = controlsc.wxSlider_GetSelEnd(self.this)
-        return val
-    def GetSelStart(self):
-        val = controlsc.wxSlider_GetSelStart(self.this)
-        return val
-    def GetThumbLength(self):
-        val = controlsc.wxSlider_GetThumbLength(self.this)
-        return val
-    def GetTickFreq(self):
-        val = controlsc.wxSlider_GetTickFreq(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxSlider_GetValue(self.this)
-        return val
-    def SetRange(self,arg0,arg1):
-        val = controlsc.wxSlider_SetRange(self.this,arg0,arg1)
-        return val
-    def SetTickFreq(self,arg0,arg1):
-        val = controlsc.wxSlider_SetTickFreq(self.this,arg0,arg1)
-        return val
-    def SetLineSize(self,arg0):
-        val = controlsc.wxSlider_SetLineSize(self.this,arg0)
-        return val
-    def SetPageSize(self,arg0):
-        val = controlsc.wxSlider_SetPageSize(self.this,arg0)
-        return val
-    def SetSelection(self,arg0,arg1):
-        val = controlsc.wxSlider_SetSelection(self.this,arg0,arg1)
-        return val
-    def SetThumbLength(self,arg0):
-        val = controlsc.wxSlider_SetThumbLength(self.this,arg0)
-        return val
-    def SetTick(self,arg0):
-        val = controlsc.wxSlider_SetTick(self.this,arg0)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxSlider_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxSlider instance>"
-class wxSlider(wxSliderPtr):
-    def __init__(self,arg0,arg1,arg2,arg3,arg4,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxSlider,(arg0.this,arg1,arg2,arg3,arg4,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/controls2.py

@@ -1,606 +0,0 @@
-# This file was created automatically by SWIG.
-import controls2c
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from events import *
-
-from controls import *
-import wx
-class wxListItemPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            controls2c.delete_wxListItem(self.this)
-    def __setattr__(self,name,value):
-        if name == "m_mask" :
-            controls2c.wxListItem_m_mask_set(self.this,value)
-            return
-        if name == "m_itemId" :
-            controls2c.wxListItem_m_itemId_set(self.this,value)
-            return
-        if name == "m_col" :
-            controls2c.wxListItem_m_col_set(self.this,value)
-            return
-        if name == "m_state" :
-            controls2c.wxListItem_m_state_set(self.this,value)
-            return
-        if name == "m_stateMask" :
-            controls2c.wxListItem_m_stateMask_set(self.this,value)
-            return
-        if name == "m_text" :
-            controls2c.wxListItem_m_text_set(self.this,value)
-            return
-        if name == "m_image" :
-            controls2c.wxListItem_m_image_set(self.this,value)
-            return
-        if name == "m_data" :
-            controls2c.wxListItem_m_data_set(self.this,value)
-            return
-        if name == "m_format" :
-            controls2c.wxListItem_m_format_set(self.this,value)
-            return
-        if name == "m_width" :
-            controls2c.wxListItem_m_width_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_mask" : 
-            return controls2c.wxListItem_m_mask_get(self.this)
-        if name == "m_itemId" : 
-            return controls2c.wxListItem_m_itemId_get(self.this)
-        if name == "m_col" : 
-            return controls2c.wxListItem_m_col_get(self.this)
-        if name == "m_state" : 
-            return controls2c.wxListItem_m_state_get(self.this)
-        if name == "m_stateMask" : 
-            return controls2c.wxListItem_m_stateMask_get(self.this)
-        if name == "m_text" : 
-            return controls2c.wxListItem_m_text_get(self.this)
-        if name == "m_image" : 
-            return controls2c.wxListItem_m_image_get(self.this)
-        if name == "m_data" : 
-            return controls2c.wxListItem_m_data_get(self.this)
-        if name == "m_format" : 
-            return controls2c.wxListItem_m_format_get(self.this)
-        if name == "m_width" : 
-            return controls2c.wxListItem_m_width_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxListItem instance>"
-class wxListItem(wxListItemPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxListItem()
-        self.thisown = 1
-
-
-
-
-class wxListEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __setattr__(self,name,value):
-        if name == "m_code" :
-            controls2c.wxListEvent_m_code_set(self.this,value)
-            return
-        if name == "m_itemIndex" :
-            controls2c.wxListEvent_m_itemIndex_set(self.this,value)
-            return
-        if name == "m_oldItemIndex" :
-            controls2c.wxListEvent_m_oldItemIndex_set(self.this,value)
-            return
-        if name == "m_col" :
-            controls2c.wxListEvent_m_col_set(self.this,value)
-            return
-        if name == "m_cancelled" :
-            controls2c.wxListEvent_m_cancelled_set(self.this,value)
-            return
-        if name == "m_pointDrag" :
-            controls2c.wxListEvent_m_pointDrag_set(self.this,value.this)
-            return
-        if name == "m_item" :
-            controls2c.wxListEvent_m_item_set(self.this,value.this)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_code" : 
-            return controls2c.wxListEvent_m_code_get(self.this)
-        if name == "m_itemIndex" : 
-            return controls2c.wxListEvent_m_itemIndex_get(self.this)
-        if name == "m_oldItemIndex" : 
-            return controls2c.wxListEvent_m_oldItemIndex_get(self.this)
-        if name == "m_col" : 
-            return controls2c.wxListEvent_m_col_get(self.this)
-        if name == "m_cancelled" : 
-            return controls2c.wxListEvent_m_cancelled_get(self.this)
-        if name == "m_pointDrag" : 
-            return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self.this))
-        if name == "m_item" : 
-            return wxListItemPtr(controls2c.wxListEvent_m_item_get(self.this))
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxListEvent instance>"
-class wxListEvent(wxListEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxListCtrlPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Arrange(self,*args):
-        val = apply(controls2c.wxListCtrl_Arrange,(self.this,)+args)
-        return val
-    def DeleteItem(self,arg0):
-        val = controls2c.wxListCtrl_DeleteItem(self.this,arg0)
-        return val
-    def DeleteAllItems(self):
-        val = controls2c.wxListCtrl_DeleteAllItems(self.this)
-        return val
-    def DeleteColumn(self,arg0):
-        val = controls2c.wxListCtrl_DeleteColumn(self.this,arg0)
-        return val
-    def DeleteAllColumns(self):
-        val = controls2c.wxListCtrl_DeleteAllColumns(self.this)
-        return val
-    def ClearAll(self):
-        val = controls2c.wxListCtrl_ClearAll(self.this)
-        return val
-    def EnsureVisible(self,arg0):
-        val = controls2c.wxListCtrl_EnsureVisible(self.this,arg0)
-        return val
-    def FindItem(self,arg0,arg1,*args):
-        val = apply(controls2c.wxListCtrl_FindItem,(self.this,arg0,arg1,)+args)
-        return val
-    def FindItemData(self,arg0,arg1):
-        val = controls2c.wxListCtrl_FindItemData(self.this,arg0,arg1)
-        return val
-    def FindItemAtPos(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_FindItemAtPos(self.this,arg0,arg1.this,arg2)
-        return val
-    def GetColumn(self,arg0,arg1):
-        val = controls2c.wxListCtrl_GetColumn(self.this,arg0,arg1.this)
-        return val
-    def GetColumnWidth(self,arg0):
-        val = controls2c.wxListCtrl_GetColumnWidth(self.this,arg0)
-        return val
-    def GetCountPerPage(self):
-        val = controls2c.wxListCtrl_GetCountPerPage(self.this)
-        return val
-    def GetImageList(self,arg0):
-        val = controls2c.wxListCtrl_GetImageList(self.this,arg0)
-        return val
-    def GetItemData(self,arg0):
-        val = controls2c.wxListCtrl_GetItemData(self.this,arg0)
-        return val
-    def GetItem(self):
-        val = controls2c.wxListCtrl_GetItem(self.this)
-        val = wxListItemPtr(val)
-        val.thisown = 1
-        return val
-    def GetItemPosition(self,arg0):
-        val = controls2c.wxListCtrl_GetItemPosition(self.this,arg0)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetItemRect(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_GetItemRect,(self.this,arg0,)+args)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def GetItemState(self,arg0,arg1):
-        val = controls2c.wxListCtrl_GetItemState(self.this,arg0,arg1)
-        return val
-    def GetItemCount(self):
-        val = controls2c.wxListCtrl_GetItemCount(self.this)
-        return val
-    def GetItemSpacing(self,arg0):
-        val = controls2c.wxListCtrl_GetItemSpacing(self.this,arg0)
-        return val
-    def GetItemText(self,arg0):
-        val = controls2c.wxListCtrl_GetItemText(self.this,arg0)
-        return val
-    def GetNextItem(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_GetNextItem,(self.this,arg0,)+args)
-        return val
-    def GetSelectedItemCount(self):
-        val = controls2c.wxListCtrl_GetSelectedItemCount(self.this)
-        return val
-    def GetTopItem(self):
-        val = controls2c.wxListCtrl_GetTopItem(self.this)
-        return val
-    def HitTest(self,arg0):
-        val = controls2c.wxListCtrl_HitTest(self.this,arg0.this)
-        return val
-    def InsertColumnWithInfo(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertColumnWithInfo(self.this,arg0,arg1.this)
-        return val
-    def InsertColumn(self,arg0,arg1,*args):
-        val = apply(controls2c.wxListCtrl_InsertColumn,(self.this,arg0,arg1,)+args)
-        return val
-    def InsertItem(self,arg0):
-        val = controls2c.wxListCtrl_InsertItem(self.this,arg0.this)
-        return val
-    def InsertStringItem(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertStringItem(self.this,arg0,arg1)
-        return val
-    def InsertImageItem(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertImageItem(self.this,arg0,arg1)
-        return val
-    def InsertImageStringItem(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_InsertImageStringItem(self.this,arg0,arg1,arg2)
-        return val
-    def ScrollList(self,arg0,arg1):
-        val = controls2c.wxListCtrl_ScrollList(self.this,arg0,arg1)
-        return val
-    def SetBackgroundColour(self,arg0):
-        val = controls2c.wxListCtrl_SetBackgroundColour(self.this,arg0.this)
-        return val
-    def SetColumn(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetColumn(self.this,arg0,arg1.this)
-        return val
-    def SetColumnWidth(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetColumnWidth(self.this,arg0,arg1)
-        return val
-    def SetImageList(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetImageList(self.this,arg0,arg1)
-        return val
-    def SetItem(self,arg0):
-        val = controls2c.wxListCtrl_SetItem(self.this,arg0.this)
-        return val
-    def SetItemString(self,arg0,arg1,arg2,*args):
-        val = apply(controls2c.wxListCtrl_SetItemString,(self.this,arg0,arg1,arg2,)+args)
-        return val
-    def SetItemData(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemData(self.this,arg0,arg1)
-        return val
-    def SetItemImage(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_SetItemImage(self.this,arg0,arg1,arg2)
-        return val
-    def SetItemPosition(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemPosition(self.this,arg0,arg1.this)
-        return val
-    def SetItemState(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_SetItemState(self.this,arg0,arg1,arg2)
-        return val
-    def SetItemText(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemText(self.this,arg0,arg1)
-        return val
-    def SetSingleStyle(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_SetSingleStyle,(self.this,arg0,)+args)
-        return val
-    def SetWindowStyleFlag(self,arg0):
-        val = controls2c.wxListCtrl_SetWindowStyleFlag(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxListCtrl instance>"
-class wxListCtrl(wxListCtrlPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controls2c.new_wxListCtrl,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxTreeItemIdPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            controls2c.delete_wxTreeItemId(self.this)
-    def IsOk(self):
-        val = controls2c.wxTreeItemId_IsOk(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxTreeItemId instance>"
-class wxTreeItemId(wxTreeItemIdPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxTreeItemId()
-        self.thisown = 1
-
-
-
-
-class wxTreeItemDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            controls2c.delete_wxTreeItemData(self.this)
-    def GetId(self):
-        val = controls2c.wxTreeItemData_GetId(self.this)
-        val = wxTreeItemIdPtr(val)
-        return val
-    def SetId(self,arg0):
-        val = controls2c.wxTreeItemData_SetId(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxTreeItemData instance>"
-class wxTreeItemData(wxTreeItemDataPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxTreeItemData()
-        self.thisown = 1
-
-
-
-
-class wxTreeEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetItem(self):
-        val = controls2c.wxTreeEvent_GetItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetOldItem(self):
-        val = controls2c.wxTreeEvent_GetOldItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetPoint(self):
-        val = controls2c.wxTreeEvent_GetPoint(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetCode(self):
-        val = controls2c.wxTreeEvent_GetCode(self.this)
-        return val
-    def Veto(self):
-        val = controls2c.wxTreeEvent_Veto(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxTreeEvent instance>"
-class wxTreeEvent(wxTreeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxTreeCtrlPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetCount(self):
-        val = controls2c.wxTreeCtrl_GetCount(self.this)
-        return val
-    def GetIndent(self):
-        val = controls2c.wxTreeCtrl_GetIndent(self.this)
-        return val
-    def SetIndent(self,arg0):
-        val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
-        return val
-    def GetImageList(self):
-        val = controls2c.wxTreeCtrl_GetImageList(self.this)
-        return val
-    def GetStateImageList(self):
-        val = controls2c.wxTreeCtrl_GetStateImageList(self.this)
-        return val
-    def SetImageList(self,arg0):
-        val = controls2c.wxTreeCtrl_SetImageList(self.this,arg0)
-        return val
-    def SetStateImageList(self,arg0):
-        val = controls2c.wxTreeCtrl_SetStateImageList(self.this,arg0)
-        return val
-    def GetItemText(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0.this)
-        return val
-    def GetItemImage(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemImage(self.this,arg0.this)
-        return val
-    def GetItemSelectedImage(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this)
-        return val
-    def GetItemData(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this)
-        val = wxTreeItemDataPtr(val)
-        return val
-    def SetItemText(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1)
-        return val
-    def SetItemImage(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0.this,arg1)
-        return val
-    def SetItemSelectedImage(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1)
-        return val
-    def SetItemData(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this)
-        return val
-    def SetItemHasChildren(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args)
-        return val
-    def IsVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this)
-        return val
-    def ItemHasChildren(self,arg0):
-        val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0.this)
-        return val
-    def IsExpanded(self,arg0):
-        val = controls2c.wxTreeCtrl_IsExpanded(self.this,arg0.this)
-        return val
-    def IsSelected(self,arg0):
-        val = controls2c.wxTreeCtrl_IsSelected(self.this,arg0.this)
-        return val
-    def GetRootItem(self):
-        val = controls2c.wxTreeCtrl_GetRootItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetSelection(self):
-        val = controls2c.wxTreeCtrl_GetSelection(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetParent(self,arg0):
-        val = controls2c.wxTreeCtrl_GetParent(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetFirstChild(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
-        return val
-    def GetNextChild(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
-        return val
-    def GetNextSibling(self,arg0):
-        val = controls2c.wxTreeCtrl_GetNextSibling(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetPrevSibling(self,arg0):
-        val = controls2c.wxTreeCtrl_GetPrevSibling(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetFirstVisibleItem(self):
-        val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetNextVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_GetNextVisible(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetPrevVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_GetPrevVisible(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def AddRoot(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_AddRoot,(self.this,arg0,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def PrependItem(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_PrependItem,(self.this,arg0.this,arg1,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def InsertItem(self,arg0,arg1,arg2,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0.this,arg1.this,arg2,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def AppendItem(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_AppendItem,(self.this,arg0.this,arg1,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def Delete(self,arg0):
-        val = controls2c.wxTreeCtrl_Delete(self.this,arg0.this)
-        return val
-    def DeleteChildren(self,arg0):
-        val = controls2c.wxTreeCtrl_DeleteChildren(self.this,arg0.this)
-        return val
-    def DeleteAllItems(self):
-        val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
-        return val
-    def Expand(self,arg0):
-        val = controls2c.wxTreeCtrl_Expand(self.this,arg0.this)
-        return val
-    def Collapse(self,arg0):
-        val = controls2c.wxTreeCtrl_Collapse(self.this,arg0.this)
-        return val
-    def CollapseAndReset(self,arg0):
-        val = controls2c.wxTreeCtrl_CollapseAndReset(self.this,arg0.this)
-        return val
-    def Toggle(self,arg0):
-        val = controls2c.wxTreeCtrl_Toggle(self.this,arg0.this)
-        return val
-    def Unselect(self):
-        val = controls2c.wxTreeCtrl_Unselect(self.this)
-        return val
-    def SelectItem(self,arg0):
-        val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0.this)
-        return val
-    def EnsureVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0.this)
-        return val
-    def ScrollTo(self,arg0):
-        val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0.this)
-        return val
-    def EditLabel(self,arg0):
-        val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0.this)
-        val = wxTextCtrlPtr(val)
-        return val
-    def GetEditControl(self):
-        val = controls2c.wxTreeCtrl_GetEditControl(self.this)
-        val = wxTextCtrlPtr(val)
-        return val
-    def EndEditLabel(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_EndEditLabel,(self.this,arg0.this,)+args)
-        return val
-    def SetItemBold(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_SetItemBold,(self.this,arg0.this,)+args)
-        return val
-    def IsBold(self,arg0):
-        val = controls2c.wxTreeCtrl_IsBold(self.this,arg0.this)
-        return val
-    def HitTest(self,arg0):
-        val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxTreeCtrl instance>"
-class wxTreeCtrl(wxTreeCtrlPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controls2c.new_wxTreeCtrl,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/events.py

@@ -1,630 +0,0 @@
-# This file was created automatically by SWIG.
-import eventsc
-
-from misc import *
-class wxEventPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetEventObject(self):
-        val = eventsc.wxEvent_GetEventObject(self.this)
-        return val
-    def GetEventType(self):
-        val = eventsc.wxEvent_GetEventType(self.this)
-        return val
-    def GetId(self):
-        val = eventsc.wxEvent_GetId(self.this)
-        return val
-    def GetSkipped(self):
-        val = eventsc.wxEvent_GetSkipped(self.this)
-        return val
-    def GetTimestamp(self):
-        val = eventsc.wxEvent_GetTimestamp(self.this)
-        return val
-    def SetEventObject(self,arg0):
-        val = eventsc.wxEvent_SetEventObject(self.this,arg0)
-        return val
-    def SetEventType(self,arg0):
-        val = eventsc.wxEvent_SetEventType(self.this,arg0)
-        return val
-    def SetId(self,arg0):
-        val = eventsc.wxEvent_SetId(self.this,arg0)
-        return val
-    def SetTimestamp(self,arg0):
-        val = eventsc.wxEvent_SetTimestamp(self.this,arg0)
-        return val
-    def Skip(self,*args):
-        val = apply(eventsc.wxEvent_Skip,(self.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxEvent instance>"
-class wxEvent(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSizeEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSize(self):
-        val = eventsc.wxSizeEvent_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxSizeEvent instance>"
-class wxSizeEvent(wxSizeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxCloseEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def CanVeto(self):
-        val = eventsc.wxCloseEvent_CanVeto(self.this)
-        return val
-    def GetLoggingOff(self):
-        val = eventsc.wxCloseEvent_GetLoggingOff(self.this)
-        return val
-    def Veto(self,*args):
-        val = apply(eventsc.wxCloseEvent_Veto,(self.this,)+args)
-        return val
-    def GetVeto(self):
-        val = eventsc.wxCloseEvent_GetVeto(self.this)
-        return val
-    def SetForce(self,arg0):
-        val = eventsc.wxCloseEvent_SetForce(self.this,arg0)
-        return val
-    def SetCanVeto(self,arg0):
-        val = eventsc.wxCloseEvent_SetCanVeto(self.this,arg0)
-        return val
-    def SetLoggingOff(self,arg0):
-        val = eventsc.wxCloseEvent_SetLoggingOff(self.this,arg0)
-        return val
-    def GetForce(self):
-        val = eventsc.wxCloseEvent_GetForce(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCloseEvent instance>"
-class wxCloseEvent(wxCloseEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxCommandEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Checked(self):
-        val = eventsc.wxCommandEvent_Checked(self.this)
-        return val
-    def GetExtraLong(self):
-        val = eventsc.wxCommandEvent_GetExtraLong(self.this)
-        return val
-    def GetInt(self):
-        val = eventsc.wxCommandEvent_GetInt(self.this)
-        return val
-    def GetSelection(self):
-        val = eventsc.wxCommandEvent_GetSelection(self.this)
-        return val
-    def GetString(self):
-        val = eventsc.wxCommandEvent_GetString(self.this)
-        return val
-    def IsSelection(self):
-        val = eventsc.wxCommandEvent_IsSelection(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCommandEvent instance>"
-class wxCommandEvent(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxScrollEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetOrientation(self):
-        val = eventsc.wxScrollEvent_GetOrientation(self.this)
-        return val
-    def GetPosition(self):
-        val = eventsc.wxScrollEvent_GetPosition(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxScrollEvent instance>"
-class wxScrollEvent(wxScrollEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSpinEventPtr(wxScrollEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxSpinEvent instance>"
-class wxSpinEvent(wxSpinEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMouseEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def IsButton(self):
-        val = eventsc.wxMouseEvent_IsButton(self.this)
-        return val
-    def ButtonDown(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonDown,(self.this,)+args)
-        return val
-    def ButtonDClick(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonDClick,(self.this,)+args)
-        return val
-    def ButtonUp(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonUp,(self.this,)+args)
-        return val
-    def Button(self,arg0):
-        val = eventsc.wxMouseEvent_Button(self.this,arg0)
-        return val
-    def ButtonIsDown(self,arg0):
-        val = eventsc.wxMouseEvent_ButtonIsDown(self.this,arg0)
-        return val
-    def ControlDown(self):
-        val = eventsc.wxMouseEvent_ControlDown(self.this)
-        return val
-    def MetaDown(self):
-        val = eventsc.wxMouseEvent_MetaDown(self.this)
-        return val
-    def AltDown(self):
-        val = eventsc.wxMouseEvent_AltDown(self.this)
-        return val
-    def ShiftDown(self):
-        val = eventsc.wxMouseEvent_ShiftDown(self.this)
-        return val
-    def LeftDown(self):
-        val = eventsc.wxMouseEvent_LeftDown(self.this)
-        return val
-    def MiddleDown(self):
-        val = eventsc.wxMouseEvent_MiddleDown(self.this)
-        return val
-    def RightDown(self):
-        val = eventsc.wxMouseEvent_RightDown(self.this)
-        return val
-    def LeftUp(self):
-        val = eventsc.wxMouseEvent_LeftUp(self.this)
-        return val
-    def MiddleUp(self):
-        val = eventsc.wxMouseEvent_MiddleUp(self.this)
-        return val
-    def RightUp(self):
-        val = eventsc.wxMouseEvent_RightUp(self.this)
-        return val
-    def LeftDClick(self):
-        val = eventsc.wxMouseEvent_LeftDClick(self.this)
-        return val
-    def MiddleDClick(self):
-        val = eventsc.wxMouseEvent_MiddleDClick(self.this)
-        return val
-    def RightDClick(self):
-        val = eventsc.wxMouseEvent_RightDClick(self.this)
-        return val
-    def LeftIsDown(self):
-        val = eventsc.wxMouseEvent_LeftIsDown(self.this)
-        return val
-    def MiddleIsDown(self):
-        val = eventsc.wxMouseEvent_MiddleIsDown(self.this)
-        return val
-    def RightIsDown(self):
-        val = eventsc.wxMouseEvent_RightIsDown(self.this)
-        return val
-    def Dragging(self):
-        val = eventsc.wxMouseEvent_Dragging(self.this)
-        return val
-    def Moving(self):
-        val = eventsc.wxMouseEvent_Moving(self.this)
-        return val
-    def Entering(self):
-        val = eventsc.wxMouseEvent_Entering(self.this)
-        return val
-    def Leaving(self):
-        val = eventsc.wxMouseEvent_Leaving(self.this)
-        return val
-    def Position(self):
-        val = eventsc.wxMouseEvent_Position(self.this)
-        return val
-    def GetPosition(self):
-        val = eventsc.wxMouseEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetLogicalPosition(self,arg0):
-        val = eventsc.wxMouseEvent_GetLogicalPosition(self.this,arg0.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetX(self):
-        val = eventsc.wxMouseEvent_GetX(self.this)
-        return val
-    def GetY(self):
-        val = eventsc.wxMouseEvent_GetY(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMouseEvent instance>"
-class wxMouseEvent(wxMouseEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxKeyEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ControlDown(self):
-        val = eventsc.wxKeyEvent_ControlDown(self.this)
-        return val
-    def MetaDown(self):
-        val = eventsc.wxKeyEvent_MetaDown(self.this)
-        return val
-    def AltDown(self):
-        val = eventsc.wxKeyEvent_AltDown(self.this)
-        return val
-    def ShiftDown(self):
-        val = eventsc.wxKeyEvent_ShiftDown(self.this)
-        return val
-    def KeyCode(self):
-        val = eventsc.wxKeyEvent_KeyCode(self.this)
-        return val
-    def Position(self):
-        val = eventsc.wxKeyEvent_Position(self.this)
-        return val
-    def GetX(self):
-        val = eventsc.wxKeyEvent_GetX(self.this)
-        return val
-    def GetY(self):
-        val = eventsc.wxKeyEvent_GetY(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxKeyEvent instance>"
-class wxKeyEvent(wxKeyEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMoveEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxMoveEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxMoveEvent instance>"
-class wxMoveEvent(wxMoveEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxPaintEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxPaintEvent instance>"
-class wxPaintEvent(wxPaintEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxEraseEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetDC(self):
-        val = eventsc.wxEraseEvent_GetDC(self.this)
-        val = wxDCPtr(val)
-        return val
-    def __repr__(self):
-        return "<C wxEraseEvent instance>"
-class wxEraseEvent(wxEraseEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxFocusEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxFocusEvent instance>"
-class wxFocusEvent(wxFocusEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxActivateEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetActive(self):
-        val = eventsc.wxActivateEvent_GetActive(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxActivateEvent instance>"
-class wxActivateEvent(wxActivateEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxInitDialogEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxInitDialogEvent instance>"
-class wxInitDialogEvent(wxInitDialogEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMenuEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetMenuId(self):
-        val = eventsc.wxMenuEvent_GetMenuId(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMenuEvent instance>"
-class wxMenuEvent(wxMenuEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxShowEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetShow(self,arg0):
-        val = eventsc.wxShowEvent_SetShow(self.this,arg0)
-        return val
-    def GetShow(self):
-        val = eventsc.wxShowEvent_GetShow(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxShowEvent instance>"
-class wxShowEvent(wxShowEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxIconizeEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxIconizeEvent instance>"
-class wxIconizeEvent(wxIconizeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMaximizeEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxMaximizeEvent instance>"
-class wxMaximizeEvent(wxMaximizeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxJoystickEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxJoystickEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetZPosition(self):
-        val = eventsc.wxJoystickEvent_GetZPosition(self.this)
-        return val
-    def GetButtonState(self):
-        val = eventsc.wxJoystickEvent_GetButtonState(self.this)
-        return val
-    def GetButtonChange(self):
-        val = eventsc.wxJoystickEvent_GetButtonChange(self.this)
-        return val
-    def GetJoystick(self):
-        val = eventsc.wxJoystickEvent_GetJoystick(self.this)
-        return val
-    def SetJoystick(self,arg0):
-        val = eventsc.wxJoystickEvent_SetJoystick(self.this,arg0)
-        return val
-    def SetButtonState(self,arg0):
-        val = eventsc.wxJoystickEvent_SetButtonState(self.this,arg0)
-        return val
-    def SetButtonChange(self,arg0):
-        val = eventsc.wxJoystickEvent_SetButtonChange(self.this,arg0)
-        return val
-    def SetPosition(self,arg0):
-        val = eventsc.wxJoystickEvent_SetPosition(self.this,arg0.this)
-        return val
-    def SetZPosition(self,arg0):
-        val = eventsc.wxJoystickEvent_SetZPosition(self.this,arg0)
-        return val
-    def IsButton(self):
-        val = eventsc.wxJoystickEvent_IsButton(self.this)
-        return val
-    def IsMove(self):
-        val = eventsc.wxJoystickEvent_IsMove(self.this)
-        return val
-    def IsZMove(self):
-        val = eventsc.wxJoystickEvent_IsZMove(self.this)
-        return val
-    def ButtonDown(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonDown,(self.this,)+args)
-        return val
-    def ButtonUp(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonUp,(self.this,)+args)
-        return val
-    def ButtonIsDown(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxJoystickEvent instance>"
-class wxJoystickEvent(wxJoystickEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxDropFilesEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxDropFilesEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetNumberOfFiles(self):
-        val = eventsc.wxDropFilesEvent_GetNumberOfFiles(self.this)
-        return val
-    def GetFiles(self):
-        val = eventsc.wxDropFilesEvent_GetFiles(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxDropFilesEvent instance>"
-class wxDropFilesEvent(wxDropFilesEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxIdleEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def RequestMore(self,*args):
-        val = apply(eventsc.wxIdleEvent_RequestMore,(self.this,)+args)
-        return val
-    def MoreRequested(self):
-        val = eventsc.wxIdleEvent_MoreRequested(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxIdleEvent instance>"
-class wxIdleEvent(wxIdleEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxUpdateUIEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetChecked(self):
-        val = eventsc.wxUpdateUIEvent_GetChecked(self.this)
-        return val
-    def GetEnabled(self):
-        val = eventsc.wxUpdateUIEvent_GetEnabled(self.this)
-        return val
-    def GetText(self):
-        val = eventsc.wxUpdateUIEvent_GetText(self.this)
-        return val
-    def GetSetText(self):
-        val = eventsc.wxUpdateUIEvent_GetSetText(self.this)
-        return val
-    def GetSetChecked(self):
-        val = eventsc.wxUpdateUIEvent_GetSetChecked(self.this)
-        return val
-    def GetSetEnabled(self):
-        val = eventsc.wxUpdateUIEvent_GetSetEnabled(self.this)
-        return val
-    def Check(self,arg0):
-        val = eventsc.wxUpdateUIEvent_Check(self.this,arg0)
-        return val
-    def Enable(self,arg0):
-        val = eventsc.wxUpdateUIEvent_Enable(self.this,arg0)
-        return val
-    def SetText(self,arg0):
-        val = eventsc.wxUpdateUIEvent_SetText(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxUpdateUIEvent instance>"
-class wxUpdateUIEvent(wxUpdateUIEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSysColourChangedEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxSysColourChangedEvent instance>"
-class wxSysColourChangedEvent(wxSysColourChangedEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/frames.py

@@ -1,124 +0,0 @@
-# This file was created automatically by SWIG.
-import framesc
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-
-from stattool import *
-
-from controls import *
-
-from events import *
-import wx
-class wxFramePtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Centre(self,*args):
-        val = apply(framesc.wxFrame_Centre,(self.this,)+args)
-        return val
-    def CreateStatusBar(self,*args):
-        val = apply(framesc.wxFrame_CreateStatusBar,(self.this,)+args)
-        val = wxStatusBarPtr(val)
-        return val
-    def CreateToolBar(self,*args):
-        val = apply(framesc.wxFrame_CreateToolBar,(self.this,)+args)
-        val = wxToolBarPtr(val)
-        return val
-    def GetMenuBar(self):
-        val = framesc.wxFrame_GetMenuBar(self.this)
-        val = wxMenuBarPtr(val)
-        return val
-    def GetStatusBar(self):
-        val = framesc.wxFrame_GetStatusBar(self.this)
-        val = wxStatusBarPtr(val)
-        return val
-    def GetTitle(self):
-        val = framesc.wxFrame_GetTitle(self.this)
-        return val
-    def GetToolBar(self):
-        val = framesc.wxFrame_GetToolBar(self.this)
-        val = wxToolBarPtr(val)
-        return val
-    def Iconize(self,arg0):
-        val = framesc.wxFrame_Iconize(self.this,arg0)
-        return val
-    def IsIconized(self):
-        val = framesc.wxFrame_IsIconized(self.this)
-        return val
-    def Maximize(self,arg0):
-        val = framesc.wxFrame_Maximize(self.this,arg0)
-        return val
-    def SetAcceleratorTable(self,arg0):
-        val = framesc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
-        return val
-    def SetIcon(self,arg0):
-        val = framesc.wxFrame_SetIcon(self.this,arg0.this)
-        return val
-    def SetMenuBar(self,arg0):
-        val = framesc.wxFrame_SetMenuBar(self.this,arg0.this)
-        return val
-    def SetStatusBar(self,arg0):
-        val = framesc.wxFrame_SetStatusBar(self.this,arg0.this)
-        return val
-    def SetStatusText(self,arg0,*args):
-        val = apply(framesc.wxFrame_SetStatusText,(self.this,arg0,)+args)
-        return val
-    def SetStatusWidths(self,arg0,*args):
-        val = apply(framesc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
-        return val
-    def SetTitle(self,arg0):
-        val = framesc.wxFrame_SetTitle(self.this,arg0)
-        return val
-    def SetToolBar(self,arg0):
-        val = framesc.wxFrame_SetToolBar(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxFrame instance>"
-class wxFrame(wxFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(framesc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-class wxMiniFramePtr(wxFramePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxMiniFrame instance>"
-class wxMiniFrame(wxMiniFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(framesc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/gdi.py

@@ -1,758 +0,0 @@
-# This file was created automatically by SWIG.
-import gdic
-
-from misc import *
-class wxBitmapPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxBitmap(self.this)
-    def GetDepth(self):
-        val = gdic.wxBitmap_GetDepth(self.this)
-        return val
-    def GetHeight(self):
-        val = gdic.wxBitmap_GetHeight(self.this)
-        return val
-    def GetPalette(self):
-        val = gdic.wxBitmap_GetPalette(self.this)
-        val = wxPalettePtr(val)
-        return val
-    def GetMask(self):
-        val = gdic.wxBitmap_GetMask(self.this)
-        val = wxMaskPtr(val)
-        return val
-    def GetWidth(self):
-        val = gdic.wxBitmap_GetWidth(self.this)
-        return val
-    def LoadFile(self,arg0,arg1):
-        val = gdic.wxBitmap_LoadFile(self.this,arg0,arg1)
-        return val
-    def Ok(self):
-        val = gdic.wxBitmap_Ok(self.this)
-        return val
-    def SaveFile(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxBitmap_SaveFile,(self.this,arg0,arg1,)+args)
-        return val
-    def SetDepth(self,arg0):
-        val = gdic.wxBitmap_SetDepth(self.this,arg0)
-        return val
-    def SetHeight(self,arg0):
-        val = gdic.wxBitmap_SetHeight(self.this,arg0)
-        return val
-    def SetMask(self,arg0):
-        val = gdic.wxBitmap_SetMask(self.this,arg0.this)
-        return val
-    def SetWidth(self,arg0):
-        val = gdic.wxBitmap_SetWidth(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxBitmap instance>"
-class wxBitmap(wxBitmapPtr):
-    def __init__(self,arg0,arg1) :
-        self.this = gdic.new_wxBitmap(arg0,arg1)
-        self.thisown = 1
-
-
-
-
-class wxMaskPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxMask(self.this)
-    def __repr__(self):
-        return "<C wxMask instance>"
-class wxMask(wxMaskPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxMask(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxIconPtr(wxBitmapPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxIcon(self.this)
-    def GetDepth(self):
-        val = gdic.wxIcon_GetDepth(self.this)
-        return val
-    def GetHeight(self):
-        val = gdic.wxIcon_GetHeight(self.this)
-        return val
-    def GetWidth(self):
-        val = gdic.wxIcon_GetWidth(self.this)
-        return val
-    def LoadFile(self,arg0,arg1):
-        val = gdic.wxIcon_LoadFile(self.this,arg0,arg1)
-        return val
-    def Ok(self):
-        val = gdic.wxIcon_Ok(self.this)
-        return val
-    def SetDepth(self,arg0):
-        val = gdic.wxIcon_SetDepth(self.this,arg0)
-        return val
-    def SetHeight(self,arg0):
-        val = gdic.wxIcon_SetHeight(self.this,arg0)
-        return val
-    def SetWidth(self,arg0):
-        val = gdic.wxIcon_SetWidth(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxIcon instance>"
-class wxIcon(wxIconPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxCursorPtr(wxBitmapPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxCursor(self.this)
-    def Ok(self):
-        val = gdic.wxCursor_Ok(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCursor instance>"
-class wxCursor(wxCursorPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxFontPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetFaceName(self):
-        val = gdic.wxFont_GetFaceName(self.this)
-        return val
-    def GetFamily(self):
-        val = gdic.wxFont_GetFamily(self.this)
-        return val
-    def GetPointSize(self):
-        val = gdic.wxFont_GetPointSize(self.this)
-        return val
-    def GetStyle(self):
-        val = gdic.wxFont_GetStyle(self.this)
-        return val
-    def GetUnderlined(self):
-        val = gdic.wxFont_GetUnderlined(self.this)
-        return val
-    def GetWeight(self):
-        val = gdic.wxFont_GetWeight(self.this)
-        return val
-    def SetFaceName(self,arg0):
-        val = gdic.wxFont_SetFaceName(self.this,arg0)
-        return val
-    def SetFamily(self,arg0):
-        val = gdic.wxFont_SetFamily(self.this,arg0)
-        return val
-    def SetPointSize(self,arg0):
-        val = gdic.wxFont_SetPointSize(self.this,arg0)
-        return val
-    def SetStyle(self,arg0):
-        val = gdic.wxFont_SetStyle(self.this,arg0)
-        return val
-    def SetUnderlined(self,arg0):
-        val = gdic.wxFont_SetUnderlined(self.this,arg0)
-        return val
-    def SetWeight(self,arg0):
-        val = gdic.wxFont_SetWeight(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxFont instance>"
-class wxFont(wxFontPtr):
-    def __init__(self,arg0,arg1,arg2,arg3,*args) :
-        self.this = apply(gdic.new_wxFont,(arg0,arg1,arg2,arg3,)+args)
-        self.thisown = 1
-
-
-
-
-class wxColourPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxColour(self.this)
-    def Red(self):
-        val = gdic.wxColour_Red(self.this)
-        return val
-    def Green(self):
-        val = gdic.wxColour_Green(self.this)
-        return val
-    def Blue(self):
-        val = gdic.wxColour_Blue(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxColour_Ok(self.this)
-        return val
-    def Set(self,arg0,arg1,arg2):
-        val = gdic.wxColour_Set(self.this,arg0,arg1,arg2)
-        return val
-    def Get(self):
-        val = gdic.wxColour_Get(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxColour instance>"
-class wxColour(wxColourPtr):
-    def __init__(self,*args) :
-        self.this = apply(gdic.new_wxColour,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPenPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetCap(self):
-        val = gdic.wxPen_GetCap(self.this)
-        return val
-    def GetColour(self):
-        val = gdic.wxPen_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetJoin(self):
-        val = gdic.wxPen_GetJoin(self.this)
-        return val
-    def GetStyle(self):
-        val = gdic.wxPen_GetStyle(self.this)
-        return val
-    def GetWidth(self):
-        val = gdic.wxPen_GetWidth(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxPen_Ok(self.this)
-        return val
-    def SetCap(self,arg0):
-        val = gdic.wxPen_SetCap(self.this,arg0)
-        return val
-    def SetColour(self,arg0):
-        val = gdic.wxPen_SetColour(self.this,arg0.this)
-        return val
-    def SetJoin(self,arg0):
-        val = gdic.wxPen_SetJoin(self.this,arg0)
-        return val
-    def SetStyle(self,arg0):
-        val = gdic.wxPen_SetStyle(self.this,arg0)
-        return val
-    def SetWidth(self,arg0):
-        val = gdic.wxPen_SetWidth(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxPen instance>"
-class wxPen(wxPenPtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(gdic.new_wxPen,(arg0.this,)+args)
-        self.thisown = 1
-
-
-
-
-class wxBrushPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetColour(self):
-        val = gdic.wxBrush_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetStipple(self):
-        val = gdic.wxBrush_GetStipple(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetStyle(self):
-        val = gdic.wxBrush_GetStyle(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxBrush_Ok(self.this)
-        return val
-    def SetColour(self,arg0):
-        val = gdic.wxBrush_SetColour(self.this,arg0.this)
-        return val
-    def SetStipple(self,arg0):
-        val = gdic.wxBrush_SetStipple(self.this,arg0.this)
-        return val
-    def SetStyle(self,arg0):
-        val = gdic.wxBrush_SetStyle(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxBrush instance>"
-class wxBrush(wxBrushPtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(gdic.new_wxBrush,(arg0.this,)+args)
-        self.thisown = 1
-
-
-
-
-class wxDCPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxDC(self.this)
-    def BeginDrawing(self):
-        val = gdic.wxDC_BeginDrawing(self.this)
-        return val
-    def Blit(self,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7):
-        val = gdic.wxDC_Blit(self.this,arg0,arg1,arg2,arg3,arg4.this,arg5,arg6,arg7)
-        return val
-    def Clear(self):
-        val = gdic.wxDC_Clear(self.this)
-        return val
-    def CrossHair(self,arg0,arg1):
-        val = gdic.wxDC_CrossHair(self.this,arg0,arg1)
-        return val
-    def DestroyClippingRegion(self):
-        val = gdic.wxDC_DestroyClippingRegion(self.this)
-        return val
-    def DeviceToLogicalX(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalX(self.this,arg0)
-        return val
-    def DeviceToLogicalXRel(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalXRel(self.this,arg0)
-        return val
-    def DeviceToLogicalY(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalY(self.this,arg0)
-        return val
-    def DeviceToLogicalYRel(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalYRel(self.this,arg0)
-        return val
-    def DrawArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
-        val = gdic.wxDC_DrawArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
-        return val
-    def DrawEllipse(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_DrawEllipse(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def DrawEllipticArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
-        val = gdic.wxDC_DrawEllipticArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
-        return val
-    def DrawIcon(self,arg0,arg1,arg2):
-        val = gdic.wxDC_DrawIcon(self.this,arg0.this,arg1,arg2)
-        return val
-    def DrawLine(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_DrawLine(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def DrawLines(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxDC_DrawLines,(self.this,arg0,)+args)
-        return val
-    def DrawPolygon(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxDC_DrawPolygon,(self.this,arg0,)+args)
-        return val
-    def DrawPoint(self,arg0,arg1):
-        val = gdic.wxDC_DrawPoint(self.this,arg0,arg1)
-        return val
-    def DrawRectangle(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_DrawRectangle(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def DrawRoundedRectangle(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(gdic.wxDC_DrawRoundedRectangle,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def DrawSpline(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxDC_DrawSpline,(self.this,arg0,)+args)
-        return val
-    def DrawText(self,arg0,arg1,arg2):
-        val = gdic.wxDC_DrawText(self.this,arg0,arg1,arg2)
-        return val
-    def EndDoc(self):
-        val = gdic.wxDC_EndDoc(self.this)
-        return val
-    def EndDrawing(self):
-        val = gdic.wxDC_EndDrawing(self.this)
-        return val
-    def EndPage(self):
-        val = gdic.wxDC_EndPage(self.this)
-        return val
-    def FloodFill(self,arg0,arg1,arg2,*args):
-        val = apply(gdic.wxDC_FloodFill,(self.this,arg0,arg1,arg2.this,)+args)
-        return val
-    def GetBackground(self):
-        val = gdic.wxDC_GetBackground(self.this)
-        val = wxBrushPtr(val)
-        return val
-    def GetBrush(self):
-        val = gdic.wxDC_GetBrush(self.this)
-        val = wxBrushPtr(val)
-        return val
-    def GetCharHeight(self):
-        val = gdic.wxDC_GetCharHeight(self.this)
-        return val
-    def GetCharWidth(self):
-        val = gdic.wxDC_GetCharWidth(self.this)
-        return val
-    def GetClippingBox(self):
-        val = gdic.wxDC_GetClippingBox(self.this)
-        return val
-    def GetFont(self):
-        val = gdic.wxDC_GetFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetLogicalFunction(self):
-        val = gdic.wxDC_GetLogicalFunction(self.this)
-        return val
-    def GetMapMode(self):
-        val = gdic.wxDC_GetMapMode(self.this)
-        return val
-    def GetOptimization(self):
-        val = gdic.wxDC_GetOptimization(self.this)
-        return val
-    def GetPen(self):
-        val = gdic.wxDC_GetPen(self.this)
-        val = wxPenPtr(val)
-        return val
-    def GetPixel(self,arg0,arg1):
-        val = gdic.wxDC_GetPixel(self.this,arg0,arg1)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def GetSize(self):
-        val = gdic.wxDC_GetSize(self.this)
-        return val
-    def GetTextBackground(self):
-        val = gdic.wxDC_GetTextBackground(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetTextExtent(self,arg0):
-        val = gdic.wxDC_GetTextExtent(self.this,arg0)
-        return val
-    def GetTextForeground(self):
-        val = gdic.wxDC_GetTextForeground(self.this)
-        val = wxColourPtr(val)
-        return val
-    def LogicalToDeviceX(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceX(self.this,arg0)
-        return val
-    def LogicalToDeviceXRel(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceXRel(self.this,arg0)
-        return val
-    def LogicalToDeviceY(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceY(self.this,arg0)
-        return val
-    def LogicalToDeviceYRel(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceYRel(self.this,arg0)
-        return val
-    def MaxX(self):
-        val = gdic.wxDC_MaxX(self.this)
-        return val
-    def MaxY(self):
-        val = gdic.wxDC_MaxY(self.this)
-        return val
-    def MinX(self):
-        val = gdic.wxDC_MinX(self.this)
-        return val
-    def MinY(self):
-        val = gdic.wxDC_MinY(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxDC_Ok(self.this)
-        return val
-    def SetDeviceOrigin(self,arg0,arg1):
-        val = gdic.wxDC_SetDeviceOrigin(self.this,arg0,arg1)
-        return val
-    def SetBackground(self,arg0):
-        val = gdic.wxDC_SetBackground(self.this,arg0.this)
-        return val
-    def SetBackgroundMode(self,arg0):
-        val = gdic.wxDC_SetBackgroundMode(self.this,arg0)
-        return val
-    def SetClippingRegion(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_SetClippingRegion(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def SetPalette(self,arg0):
-        val = gdic.wxDC_SetPalette(self.this,arg0.this)
-        return val
-    def SetBrush(self,arg0):
-        val = gdic.wxDC_SetBrush(self.this,arg0.this)
-        return val
-    def SetFont(self,arg0):
-        val = gdic.wxDC_SetFont(self.this,arg0.this)
-        return val
-    def SetLogicalFunction(self,arg0):
-        val = gdic.wxDC_SetLogicalFunction(self.this,arg0)
-        return val
-    def SetMapMode(self,arg0):
-        val = gdic.wxDC_SetMapMode(self.this,arg0)
-        return val
-    def SetOptimization(self,arg0):
-        val = gdic.wxDC_SetOptimization(self.this,arg0)
-        return val
-    def SetPen(self,arg0):
-        val = gdic.wxDC_SetPen(self.this,arg0.this)
-        return val
-    def SetTextBackground(self,arg0):
-        val = gdic.wxDC_SetTextBackground(self.this,arg0.this)
-        return val
-    def SetTextForeground(self,arg0):
-        val = gdic.wxDC_SetTextForeground(self.this,arg0.this)
-        return val
-    def SetUserScale(self,arg0,arg1):
-        val = gdic.wxDC_SetUserScale(self.this,arg0,arg1)
-        return val
-    def StartDoc(self,arg0):
-        val = gdic.wxDC_StartDoc(self.this,arg0)
-        return val
-    def StartPage(self):
-        val = gdic.wxDC_StartPage(self.this)
-        return val
-    def DrawBitmap(self,arg0,arg1,arg2,*args):
-        val = apply(gdic.wxDC_DrawBitmap,(self.this,arg0.this,arg1,arg2,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxDC instance>"
-class wxDC(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMemoryDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SelectObject(self,arg0):
-        val = gdic.wxMemoryDC_SelectObject(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxMemoryDC instance>"
-class wxMemoryDC(wxMemoryDCPtr):
-    def __init__(self) :
-        self.this = gdic.new_wxMemoryDC()
-        self.thisown = 1
-
-
-
-
-class wxScreenDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def StartDrawingOnTop(self,arg0):
-        val = gdic.wxScreenDC_StartDrawingOnTop(self.this,arg0.this)
-        return val
-    def StartDrawingOnTopRect(self,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxScreenDC_StartDrawingOnTopRect,(self.this,)+args)
-        return val
-    def EndDrawingOnTop(self):
-        val = gdic.wxScreenDC_EndDrawingOnTop(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxScreenDC instance>"
-class wxScreenDC(wxScreenDCPtr):
-    def __init__(self) :
-        self.this = gdic.new_wxScreenDC()
-        self.thisown = 1
-
-
-
-
-class wxClientDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxClientDC instance>"
-class wxClientDC(wxClientDCPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxClientDC(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxPaintDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxPaintDC instance>"
-class wxPaintDC(wxPaintDCPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxPaintDC(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxWindowDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxWindowDC instance>"
-class wxWindowDC(wxWindowDCPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxWindowDC(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxPostScriptDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxPostScriptDC instance>"
-class wxPostScriptDC(wxPostScriptDCPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(gdic.new_wxPostScriptDC,(arg0,)+args)
-        self.thisown = 1
-
-
-
-
-class wxPalettePtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxPalette(self.this)
-    def GetPixel(self,arg0,arg1,arg2):
-        val = gdic.wxPalette_GetPixel(self.this,arg0,arg1,arg2)
-        return val
-    def GetRGB(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxPalette_GetRGB(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def Ok(self):
-        val = gdic.wxPalette_Ok(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPalette instance>"
-class wxPalette(wxPalettePtr):
-    def __init__(self,arg0,arg1,arg2) :
-        self.this = gdic.new_wxPalette(arg0,arg1,arg2)
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-def wxEmptyBitmap(arg0,arg1,*args):
-    val = apply(gdic.wxEmptyBitmap,(arg0,arg1,)+args)
-    val = wxBitmapPtr(val)
-    val.thisown = 1
-    return val
-
-def wxNoRefBitmap(arg0,arg1):
-    val = gdic.wxNoRefBitmap(arg0,arg1)
-    val = wxBitmapPtr(val)
-    return val
-
-def wxMaskColour(arg0,arg1):
-    val = gdic.wxMaskColour(arg0.this,arg1.this)
-    val = wxMaskPtr(val)
-    val.thisown = 1
-    return val
-
-def wxStockCursor(arg0):
-    val = gdic.wxStockCursor(arg0)
-    val = wxCursorPtr(val)
-    val.thisown = 1
-    return val
-
-def wxNamedColour(arg0):
-    val = gdic.wxNamedColour(arg0)
-    val = wxColourPtr(val)
-    val.thisown = 1
-    return val
-
-def wxMemoryDCFromDC(arg0):
-    val = gdic.wxMemoryDCFromDC(arg0.this)
-    val = wxMemoryDCPtr(val)
-    val.thisown = 1
-    return val
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-cvar = gdic.cvar
-wxNORMAL_FONT = wxFontPtr(gdic.cvar.wxNORMAL_FONT)
-wxSMALL_FONT = wxFontPtr(gdic.cvar.wxSMALL_FONT)
-wxITALIC_FONT = wxFontPtr(gdic.cvar.wxITALIC_FONT)
-wxSWISS_FONT = wxFontPtr(gdic.cvar.wxSWISS_FONT)
-wxRED_PEN = wxPenPtr(gdic.cvar.wxRED_PEN)
-wxCYAN_PEN = wxPenPtr(gdic.cvar.wxCYAN_PEN)
-wxGREEN_PEN = wxPenPtr(gdic.cvar.wxGREEN_PEN)
-wxBLACK_PEN = wxPenPtr(gdic.cvar.wxBLACK_PEN)
-wxWHITE_PEN = wxPenPtr(gdic.cvar.wxWHITE_PEN)
-wxTRANSPARENT_PEN = wxPenPtr(gdic.cvar.wxTRANSPARENT_PEN)
-wxBLACK_DASHED_PEN = wxPenPtr(gdic.cvar.wxBLACK_DASHED_PEN)
-wxGREY_PEN = wxPenPtr(gdic.cvar.wxGREY_PEN)
-wxMEDIUM_GREY_PEN = wxPenPtr(gdic.cvar.wxMEDIUM_GREY_PEN)
-wxLIGHT_GREY_PEN = wxPenPtr(gdic.cvar.wxLIGHT_GREY_PEN)
-wxBLUE_BRUSH = wxBrushPtr(gdic.cvar.wxBLUE_BRUSH)
-wxGREEN_BRUSH = wxBrushPtr(gdic.cvar.wxGREEN_BRUSH)
-wxWHITE_BRUSH = wxBrushPtr(gdic.cvar.wxWHITE_BRUSH)
-wxBLACK_BRUSH = wxBrushPtr(gdic.cvar.wxBLACK_BRUSH)
-wxTRANSPARENT_BRUSH = wxBrushPtr(gdic.cvar.wxTRANSPARENT_BRUSH)
-wxCYAN_BRUSH = wxBrushPtr(gdic.cvar.wxCYAN_BRUSH)
-wxRED_BRUSH = wxBrushPtr(gdic.cvar.wxRED_BRUSH)
-wxGREY_BRUSH = wxBrushPtr(gdic.cvar.wxGREY_BRUSH)
-wxMEDIUM_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxMEDIUM_GREY_BRUSH)
-wxLIGHT_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxLIGHT_GREY_BRUSH)
-wxBLACK = wxColourPtr(gdic.cvar.wxBLACK)
-wxWHITE = wxColourPtr(gdic.cvar.wxWHITE)
-wxRED = wxColourPtr(gdic.cvar.wxRED)
-wxBLUE = wxColourPtr(gdic.cvar.wxBLUE)
-wxGREEN = wxColourPtr(gdic.cvar.wxGREEN)
-wxCYAN = wxColourPtr(gdic.cvar.wxCYAN)
-wxLIGHT_GREY = wxColourPtr(gdic.cvar.wxLIGHT_GREY)
-wxSTANDARD_CURSOR = wxCursorPtr(gdic.cvar.wxSTANDARD_CURSOR)
-wxHOURGLASS_CURSOR = wxCursorPtr(gdic.cvar.wxHOURGLASS_CURSOR)
-wxCROSS_CURSOR = wxCursorPtr(gdic.cvar.wxCROSS_CURSOR)
-wxNullBitmap = wxBitmapPtr(gdic.cvar.wxNullBitmap)
-wxNullIcon = wxIconPtr(gdic.cvar.wxNullIcon)
-wxNullCursor = wxCursorPtr(gdic.cvar.wxNullCursor)
-wxNullPen = wxPenPtr(gdic.cvar.wxNullPen)
-wxNullBrush = wxBrushPtr(gdic.cvar.wxNullBrush)
-wxNullFont = wxFontPtr(gdic.cvar.wxNullFont)
-wxNullColour = wxColourPtr(gdic.cvar.wxNullColour)

utils/wxPython/src/gtk/mdi.cpp

@@ -1,964 +0,0 @@
-/*
- * FILE : gtk/mdi.cpp
- * 
- * This file was automatically generated by :
- * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Patch 5)
- * 
- * Portions Copyright (c) 1995-1998
- * The University of Utah and The Regents of the University of California.
- * Permission is granted to distribute this file in any manner provided
- * this notice remains intact.
- * 
- * Do not make changes to this file--changes will be lost!
- *
- */
-
-
-#define SWIGCODE
-/* Implementation : PYTHON */
-
-#define SWIGPYTHON
-#include <string.h>
-#include <stdlib.h>
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a,b) __declspec(dllexport) a b
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a,b) a _export b
-#	else
-#	    define SWIGEXPORT(a,b) a b
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a,b) a b
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "Python.h"
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif
-
-#define SWIG_init    initmdic
-
-#define SWIG_name    "mdic"
-
-#include "helpers.h"
-
-static PyObject* l_output_helper(PyObject* target, PyObject* o) {
-    PyObject*   o2;
-    PyObject*   o3;
-    if (!target) {                   
-        target = o;
-    } else if (target == Py_None) {  
-        Py_DECREF(Py_None);
-        target = o;
-    } else {                         
-        if (!PyList_Check(target)) {
-            o2 = target;
-            target = PyList_New(0);
-            PyList_Append(target, o2);
-	    Py_XDECREF(o2);
-        }
-        PyList_Append(target,o);
-	Py_XDECREF(o);
-    }
-    return target;
-}
-
-static PyObject* t_output_helper(PyObject* target, PyObject* o) {
-    PyObject*   o2;
-    PyObject*   o3;
-
-    if (!target) {                   
-        target = o;
-    } else if (target == Py_None) {  
-        Py_DECREF(Py_None);
-        target = o;
-    } else {                         
-        if (!PyTuple_Check(target)) {
-            o2 = target;
-            target = PyTuple_New(1);
-            PyTuple_SetItem(target, 0, o2);
-        }
-        o3 = PyTuple_New(1);            
-        PyTuple_SetItem(o3, 0, o);      
-
-        o2 = target;
-        target = PySequence_Concat(o2, o3); 
-        Py_DECREF(o2);                      
-        Py_DECREF(o3);
-    }
-    return target;
-}
-
-
-extern byte* byte_LIST_helper(PyObject* source);
-extern int* int_LIST_helper(PyObject* source);
-extern long* long_LIST_helper(PyObject* source);
-extern char** string_LIST_helper(PyObject* source);
-extern wxPoint* wxPoint_LIST_helper(PyObject* source);
-extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-extern wxString* wxString_LIST_helper(PyObject* source);
-extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
-static char* wxStringErrorMsg = "string type is required for parameter";
-static void *SwigwxMDIParentFrameTowxFrame(void *ptr) {
-    wxMDIParentFrame *src;
-    wxFrame *dest;
-    src = (wxMDIParentFrame *) ptr;
-    dest = (wxFrame *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIParentFrameTowxWindow(void *ptr) {
-    wxMDIParentFrame *src;
-    wxWindow *dest;
-    src = (wxMDIParentFrame *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIParentFrameTowxEvtHandler(void *ptr) {
-    wxMDIParentFrame *src;
-    wxEvtHandler *dest;
-    src = (wxMDIParentFrame *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-#define new_wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
-static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _result;
-    wxWindow * _arg0;
-    wxWindowID  _arg1;
-    wxString * _arg2;
-    wxPoint * _arg3 = &wxPyDefaultPosition;
-    wxSize * _arg4 = &wxPyDefaultSize;
-    long  _arg5 = (wxDEFAULT_FRAME_STYLE)|(wxVSCROLL)|(wxHSCROLL);
-    char * _arg6 = "frame";
-    char * _argc0 = 0;
-    PyObject * _obj2 = 0;
-    char * _argc3 = 0;
-    char * _argc4 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIParentFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIParentFrame. Expected _wxWindow_p.");
-        return NULL;
-        }
-    }
-{
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AsString(_obj2));
-}
-    if (_argc3) {
-        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIParentFrame. Expected _wxPoint_p.");
-        return NULL;
-        }
-    }
-    if (_argc4) {
-        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIParentFrame. Expected _wxSize_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-{
-    if (_obj2)
-        delete _arg2;
-}
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_ActivateNext(_swigobj)  (_swigobj->ActivateNext())
-static PyObject *_wrap_wxMDIParentFrame_ActivateNext(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivateNext",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivateNext. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_ActivateNext(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_ActivatePrevious(_swigobj)  (_swigobj->ActivatePrevious())
-static PyObject *_wrap_wxMDIParentFrame_ActivatePrevious(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivatePrevious",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivatePrevious. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_ActivatePrevious(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_ArrangeIcons(_swigobj)  (_swigobj->ArrangeIcons())
-static PyObject *_wrap_wxMDIParentFrame_ArrangeIcons(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ArrangeIcons",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ArrangeIcons. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_ArrangeIcons(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_Cascade(_swigobj)  (_swigobj->Cascade())
-static PyObject *_wrap_wxMDIParentFrame_Cascade(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Cascade",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Cascade. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_Cascade(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetClientSize(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxMDIParentFrame_GetClientSize(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    int * _arg1;
-    int  temp;
-    int * _arg2;
-    int  temp0;
-    char * _argc0 = 0;
-
-    self = self;
-{
-  _arg1 = &temp;
-}
-{
-  _arg2 = &temp0;
-}
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientSize",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientSize. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_GetClientSize(_arg0,_arg1,_arg2);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg1));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg2));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetActiveChild(_swigobj)  (_swigobj->GetActiveChild())
-static PyObject *_wrap_wxMDIParentFrame_GetActiveChild(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _result;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetActiveChild",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetActiveChild. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetClientWindow(_swigobj)  (_swigobj->GetClientWindow())
-static PyObject *_wrap_wxMDIParentFrame_GetClientWindow(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIClientWindow * _result;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientWindow",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientWindow. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetToolBar(_swigobj)  (_swigobj->GetToolBar())
-static PyObject *_wrap_wxMDIParentFrame_GetToolBar(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxWindow * _result;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetToolBar",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetToolBar. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_Tile(_swigobj)  (_swigobj->Tile())
-static PyObject *_wrap_wxMDIParentFrame_Tile(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Tile",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Tile. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_Tile(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-static void *SwigwxMDIChildFrameTowxFrame(void *ptr) {
-    wxMDIChildFrame *src;
-    wxFrame *dest;
-    src = (wxMDIChildFrame *) ptr;
-    dest = (wxFrame *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIChildFrameTowxWindow(void *ptr) {
-    wxMDIChildFrame *src;
-    wxWindow *dest;
-    src = (wxMDIChildFrame *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIChildFrameTowxEvtHandler(void *ptr) {
-    wxMDIChildFrame *src;
-    wxEvtHandler *dest;
-    src = (wxMDIChildFrame *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-#define new_wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
-static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _result;
-    wxMDIParentFrame * _arg0;
-    wxWindowID  _arg1;
-    wxString * _arg2;
-    wxPoint * _arg3 = &wxPyDefaultPosition;
-    wxSize * _arg4 = &wxPyDefaultSize;
-    long  _arg5 = (wxDEFAULT_FRAME_STYLE);
-    char * _arg6 = "frame";
-    char * _argc0 = 0;
-    PyObject * _obj2 = 0;
-    char * _argc3 = 0;
-    char * _argc4 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIChildFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIChildFrame. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-{
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AsString(_obj2));
-}
-    if (_argc3) {
-        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIChildFrame. Expected _wxPoint_p.");
-        return NULL;
-        }
-    }
-    if (_argc4) {
-        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIChildFrame. Expected _wxSize_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-{
-    if (_obj2)
-        delete _arg2;
-}
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_Activate(_swigobj)  (_swigobj->Activate())
-static PyObject *_wrap_wxMDIChildFrame_Activate(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Activate",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Activate. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_Activate(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_Maximize(_swigobj)  (_swigobj->Maximize())
-static PyObject *_wrap_wxMDIChildFrame_Maximize(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Maximize",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Maximize. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_Maximize(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_Restore(_swigobj)  (_swigobj->Restore())
-static PyObject *_wrap_wxMDIChildFrame_Restore(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Restore",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Restore. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_Restore(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_SetMenuBar(_swigobj,_swigarg0)  (_swigobj->SetMenuBar(_swigarg0))
-static PyObject *_wrap_wxMDIChildFrame_SetMenuBar(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    wxMenuBar * _arg1;
-    char * _argc0 = 0;
-    char * _argc1 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"ss:wxMDIChildFrame_SetMenuBar",&_argc0,&_argc1)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetMenuBar. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    if (_argc1) {
-        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxMenuBar_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIChildFrame_SetMenuBar. Expected _wxMenuBar_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_SetMenuBar(_arg0,_arg1);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_SetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetClientSize(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxMDIChildFrame_SetClientSize(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    int  _arg1;
-    int  _arg2;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"sii:wxMDIChildFrame_SetClientSize",&_argc0,&_arg1,&_arg2)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetClientSize. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_SetClientSize(_arg0,_arg1,_arg2);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_GetPosition(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetPosition(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxMDIChildFrame_GetPosition(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    int * _arg1;
-    int  temp;
-    int * _arg2;
-    int  temp0;
-    char * _argc0 = 0;
-
-    self = self;
-{
-  _arg1 = &temp;
-}
-{
-  _arg2 = &temp0;
-}
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_GetPosition",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_GetPosition. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_GetPosition(_arg0,_arg1,_arg2);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg1));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg2));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-    return _resultobj;
-}
-
-static void *SwigwxMDIClientWindowTowxWindow(void *ptr) {
-    wxMDIClientWindow *src;
-    wxWindow *dest;
-    src = (wxMDIClientWindow *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIClientWindowTowxEvtHandler(void *ptr) {
-    wxMDIClientWindow *src;
-    wxEvtHandler *dest;
-    src = (wxMDIClientWindow *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-#define new_wxMDIClientWindow(_swigarg0,_swigarg1) (new wxMDIClientWindow(_swigarg0,_swigarg1))
-static PyObject *_wrap_new_wxMDIClientWindow(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIClientWindow * _result;
-    wxMDIParentFrame * _arg0;
-    long  _arg1 = 0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s|l:new_wxMDIClientWindow",&_argc0,&_arg1)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIClientWindow. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-static PyMethodDef mdicMethods[] = {
-	 { "new_wxMDIClientWindow", _wrap_new_wxMDIClientWindow, 1 },
-	 { "wxMDIChildFrame_GetPosition", _wrap_wxMDIChildFrame_GetPosition, 1 },
-	 { "wxMDIChildFrame_SetClientSize", _wrap_wxMDIChildFrame_SetClientSize, 1 },
-	 { "wxMDIChildFrame_SetMenuBar", _wrap_wxMDIChildFrame_SetMenuBar, 1 },
-	 { "wxMDIChildFrame_Restore", _wrap_wxMDIChildFrame_Restore, 1 },
-	 { "wxMDIChildFrame_Maximize", _wrap_wxMDIChildFrame_Maximize, 1 },
-	 { "wxMDIChildFrame_Activate", _wrap_wxMDIChildFrame_Activate, 1 },
-	 { "new_wxMDIChildFrame", _wrap_new_wxMDIChildFrame, 1 },
-	 { "wxMDIParentFrame_Tile", _wrap_wxMDIParentFrame_Tile, 1 },
-	 { "wxMDIParentFrame_GetToolBar", _wrap_wxMDIParentFrame_GetToolBar, 1 },
-	 { "wxMDIParentFrame_GetClientWindow", _wrap_wxMDIParentFrame_GetClientWindow, 1 },
-	 { "wxMDIParentFrame_GetActiveChild", _wrap_wxMDIParentFrame_GetActiveChild, 1 },
-	 { "wxMDIParentFrame_GetClientSize", _wrap_wxMDIParentFrame_GetClientSize, 1 },
-	 { "wxMDIParentFrame_Cascade", _wrap_wxMDIParentFrame_Cascade, 1 },
-	 { "wxMDIParentFrame_ArrangeIcons", _wrap_wxMDIParentFrame_ArrangeIcons, 1 },
-	 { "wxMDIParentFrame_ActivatePrevious", _wrap_wxMDIParentFrame_ActivatePrevious, 1 },
-	 { "wxMDIParentFrame_ActivateNext", _wrap_wxMDIParentFrame_ActivateNext, 1 },
-	 { "new_wxMDIParentFrame", _wrap_new_wxMDIParentFrame, 1 },
-	 { NULL, NULL }
-};
-static PyObject *SWIG_globals;
-#ifdef __cplusplus
-extern "C" 
-#endif
-SWIGEXPORT(void,initmdic)() {
-	 PyObject *m, *d;
-	 SWIG_globals = SWIG_newvarlink();
-	 m = Py_InitModule("mdic", mdicMethods);
-	 d = PyModule_GetDict(m);
-/*
- * These are the pointer type-equivalency mappings. 
- * (Used by the SWIG pointer type-checker).
- */
-	 SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
-	 SWIG_RegisterMapping("_wxEvent","_class_wxEvent",0);
-	 SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
-	 SWIG_RegisterMapping("_signed_long","_long",0);
-	 SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
-	 SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
-	 SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
-	 SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
-	 SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
-	 SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
-	 SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
-	 SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
-	 SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
-	 SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
-	 SWIG_RegisterMapping("_byte","_unsigned_char",0);
-	 SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0);
-	 SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
-	 SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
-	 SWIG_RegisterMapping("_long","_wxDash",0);
-	 SWIG_RegisterMapping("_long","_unsigned_long",0);
-	 SWIG_RegisterMapping("_long","_signed_long",0);
-	 SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0);
-	 SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0);
-	 SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
-	 SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
-	 SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
-	 SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
-	 SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
-	 SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
-	 SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0);
-	 SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0);
-	 SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0);
-	 SWIG_RegisterMapping("_class_wxPostScriptDC","_wxPostScriptDC",0);
-	 SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
-	 SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0);
-	 SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0);
-	 SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0);
-	 SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
-	 SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0);
-	 SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
-	 SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
-	 SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
-	 SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
-	 SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
-	 SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
-	 SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
-	 SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
-	 SWIG_RegisterMapping("_uint","_unsigned_int",0);
-	 SWIG_RegisterMapping("_uint","_int",0);
-	 SWIG_RegisterMapping("_uint","_wxWindowID",0);
-	 SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
-	 SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
-	 SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
-	 SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
-	 SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0);
-	 SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
-	 SWIG_RegisterMapping("_class_wxButton","_wxButton",0);
-	 SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0);
-	 SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
-	 SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
-	 SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
-	 SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
-	 SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
-	 SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
-	 SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
-	 SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
-	 SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
-	 SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
-	 SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
-	 SWIG_RegisterMapping("_EBool","_signed_int",0);
-	 SWIG_RegisterMapping("_EBool","_int",0);
-	 SWIG_RegisterMapping("_EBool","_wxWindowID",0);
-	 SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
-	 SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0);
-	 SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
-	 SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
-	 SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
-	 SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
-	 SWIG_RegisterMapping("_unsigned_long","_long",0);
-	 SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
-	 SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
-	 SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0);
-	 SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
-	 SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0);
-	 SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxSpinButton","_wxSpinButton",0);
-	 SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
-	 SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
-	 SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
-	 SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
-	 SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
-	 SWIG_RegisterMapping("_signed_int","_EBool",0);
-	 SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_signed_int","_int",0);
-	 SWIG_RegisterMapping("_class_wxTextCtrl","_wxTextCtrl",0);
-	 SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
-	 SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
-	 SWIG_RegisterMapping("_class_wxMoveEvent","_wxMoveEvent",0);
-	 SWIG_RegisterMapping("_wxListBox","_class_wxListBox",0);
-	 SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
-	 SWIG_RegisterMapping("_class_wxMDIChildFrame","_wxMDIChildFrame",0);
-	 SWIG_RegisterMapping("_WXTYPE","_short",0);
-	 SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
-	 SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
-	 SWIG_RegisterMapping("_class_wxMDIClientWindow","_wxMDIClientWindow",0);
-	 SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
-	 SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_unsigned_short","_short",0);
-	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
-	 SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0);
-	 SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
-	 SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0);
-	 SWIG_RegisterMapping("_class_wxMenuEvent","_wxMenuEvent",0);
-	 SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
-	 SWIG_RegisterMapping("_wxMouseEvent","_class_wxMouseEvent",0);
-	 SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
-	 SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
-	 SWIG_RegisterMapping("_class_wxRadioBox","_wxRadioBox",0);
-	 SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_signed_short","_short",0);
-	 SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
-	 SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
-	 SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
-	 SWIG_RegisterMapping("_class_wxFocusEvent","_wxFocusEvent",0);
-	 SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0);
-	 SWIG_RegisterMapping("_wxStatusBar","_class_wxStatusBar",0);
-	 SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0);
-	 SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
-	 SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
-	 SWIG_RegisterMapping("_wxPostScriptDC","_class_wxPostScriptDC",0);
-	 SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
-	 SWIG_RegisterMapping("_unsigned_char","_byte",0);
-	 SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
-	 SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
-	 SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
-	 SWIG_RegisterMapping("_unsigned_int","_uint",0);
-	 SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_unsigned_int","_int",0);
-	 SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
-	 SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
-	 SWIG_RegisterMapping("_class_wxPyMenu","_wxPyMenu",0);
-	 SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
-	 SWIG_RegisterMapping("_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_short","_unsigned_short",0);
-	 SWIG_RegisterMapping("_short","_signed_short",0);
-	 SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0);
-	 SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
-	 SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
-	 SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0);
-	 SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
-	 SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
-	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
-	 SWIG_RegisterMapping("_wxWindowID","_EBool",0);
-	 SWIG_RegisterMapping("_wxWindowID","_uint",0);
-	 SWIG_RegisterMapping("_wxWindowID","_int",0);
-	 SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
-	 SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
-	 SWIG_RegisterMapping("_int","_EBool",0);
-	 SWIG_RegisterMapping("_int","_uint",0);
-	 SWIG_RegisterMapping("_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_int","_unsigned_int",0);
-	 SWIG_RegisterMapping("_int","_signed_int",0);
-	 SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0);
-	 SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0);
-	 SWIG_RegisterMapping("_wxButton","_class_wxButton",0);
-	 SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
-	 SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
-	 SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0);
-	 SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
-	 SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0);
-	 SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0);
-	 SWIG_RegisterMapping("_class_wxComboBox","_wxComboBox",0);
-	 SWIG_RegisterMapping("_class_wxRadioButton","_wxRadioButton",0);
-	 SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
-	 SWIG_RegisterMapping("_wxIconizeEvent","_class_wxIconizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxControl","_wxControl",0);
-	 SWIG_RegisterMapping("_wxStaticBitmap","_class_wxStaticBitmap",0);
-	 SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
-	 SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
-	 SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
-	 SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
-	 SWIG_RegisterMapping("_class_wxIdleEvent","_wxIdleEvent",0);
-	 SWIG_RegisterMapping("_wxEraseEvent","_class_wxEraseEvent",0);
-	 SWIG_RegisterMapping("_class_wxJoystickEvent","_wxJoystickEvent",0);
-	 SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0);
-	 SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
-	 SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
-	 SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
-	 SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
-	 SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0);
-	 SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0);
-	 SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
-	 SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
-	 SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
-	 SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
-	 SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
-	 SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
-	 SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0);
-	 SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
-	 SWIG_RegisterMapping("_wxDash","_long",0);
-	 SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
-	 SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0);
-	 SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0);
-	 SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
-	 SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0);
-	 SWIG_RegisterMapping("_wxMDIClientWindow","_class_wxMDIClientWindow",0);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
-	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_wxFrame",0);
-}

utils/wxPython/src/gtk/mdi.py

@@ -1,131 +0,0 @@
-# This file was created automatically by SWIG.
-import mdic
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from events import *
-import wx
-class wxMDIParentFramePtr(wxFramePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ActivateNext(self):
-        val = mdic.wxMDIParentFrame_ActivateNext(self.this)
-        return val
-    def ActivatePrevious(self):
-        val = mdic.wxMDIParentFrame_ActivatePrevious(self.this)
-        return val
-    def ArrangeIcons(self):
-        val = mdic.wxMDIParentFrame_ArrangeIcons(self.this)
-        return val
-    def Cascade(self):
-        val = mdic.wxMDIParentFrame_Cascade(self.this)
-        return val
-    def GetClientSize(self):
-        val = mdic.wxMDIParentFrame_GetClientSize(self.this)
-        return val
-    def GetActiveChild(self):
-        val = mdic.wxMDIParentFrame_GetActiveChild(self.this)
-        val = wxMDIChildFramePtr(val)
-        return val
-    def GetClientWindow(self):
-        val = mdic.wxMDIParentFrame_GetClientWindow(self.this)
-        val = wxMDIClientWindowPtr(val)
-        return val
-    def GetToolBar(self):
-        val = mdic.wxMDIParentFrame_GetToolBar(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def Tile(self):
-        val = mdic.wxMDIParentFrame_Tile(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMDIParentFrame instance>"
-class wxMDIParentFrame(wxMDIParentFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(mdic.new_wxMDIParentFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-class wxMDIChildFramePtr(wxFramePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Activate(self):
-        val = mdic.wxMDIChildFrame_Activate(self.this)
-        return val
-    def Maximize(self):
-        val = mdic.wxMDIChildFrame_Maximize(self.this)
-        return val
-    def Restore(self):
-        val = mdic.wxMDIChildFrame_Restore(self.this)
-        return val
-    def SetMenuBar(self,arg0):
-        val = mdic.wxMDIChildFrame_SetMenuBar(self.this,arg0.this)
-        return val
-    def SetClientSize(self,arg0,arg1):
-        val = mdic.wxMDIChildFrame_SetClientSize(self.this,arg0,arg1)
-        return val
-    def GetPosition(self):
-        val = mdic.wxMDIChildFrame_GetPosition(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMDIChildFrame instance>"
-class wxMDIChildFrame(wxMDIChildFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(mdic.new_wxMDIChildFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-class wxMDIClientWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxMDIClientWindow instance>"
-class wxMDIClientWindow(wxMDIClientWindowPtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(mdic.new_wxMDIClientWindow,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._StdOnScrollCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/misc.py

@@ -1,617 +0,0 @@
-# This file was created automatically by SWIG.
-import miscc
-class wxSizePtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxSize(self.this)
-    def Set(self,arg0,arg1):
-        val = miscc.wxSize_Set(self.this,arg0,arg1)
-        return val
-    def GetWidth(self):
-        val = miscc.wxSize_GetWidth(self.this)
-        return val
-    def GetHeight(self):
-        val = miscc.wxSize_GetHeight(self.this)
-        return val
-    def __str__(self):
-        val = miscc.wxSize___str__(self.this)
-        return val
-    def __setattr__(self,name,value):
-        if name == "width" :
-            miscc.wxSize_width_set(self.this,value)
-            return
-        if name == "height" :
-            miscc.wxSize_height_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "width" : 
-            return miscc.wxSize_width_get(self.this)
-        if name == "height" : 
-            return miscc.wxSize_height_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxSize instance>"
-class wxSize(wxSizePtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxSize,()+args)
-        self.thisown = 1
-
-
-
-
-class wxRealPointPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRealPoint(self.this)
-    def __setattr__(self,name,value):
-        if name == "x" :
-            miscc.wxRealPoint_x_set(self.this,value)
-            return
-        if name == "y" :
-            miscc.wxRealPoint_y_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "x" : 
-            return miscc.wxRealPoint_x_get(self.this)
-        if name == "y" : 
-            return miscc.wxRealPoint_y_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxRealPoint instance>"
-class wxRealPoint(wxRealPointPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxRealPoint,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPointPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxPoint(self.this)
-    def Set(self,arg0,arg1):
-        val = miscc.wxPoint_Set(self.this,arg0,arg1)
-        return val
-    def __str__(self):
-        val = miscc.wxPoint___str__(self.this)
-        return val
-    def __setattr__(self,name,value):
-        if name == "x" :
-            miscc.wxPoint_x_set(self.this,value)
-            return
-        if name == "y" :
-            miscc.wxPoint_y_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "x" : 
-            return miscc.wxPoint_x_get(self.this)
-        if name == "y" : 
-            return miscc.wxPoint_y_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxPoint instance>"
-class wxPoint(wxPointPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxPoint,()+args)
-        self.thisown = 1
-
-
-
-
-class wxRectPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRect(self.this)
-    def GetX(self):
-        val = miscc.wxRect_GetX(self.this)
-        return val
-    def SetX(self,arg0):
-        val = miscc.wxRect_SetX(self.this,arg0)
-        return val
-    def GetY(self):
-        val = miscc.wxRect_GetY(self.this)
-        return val
-    def SetY(self,arg0):
-        val = miscc.wxRect_SetY(self.this,arg0)
-        return val
-    def GetWidth(self):
-        val = miscc.wxRect_GetWidth(self.this)
-        return val
-    def SetWidth(self,arg0):
-        val = miscc.wxRect_SetWidth(self.this,arg0)
-        return val
-    def GetHeight(self):
-        val = miscc.wxRect_GetHeight(self.this)
-        return val
-    def SetHeight(self,arg0):
-        val = miscc.wxRect_SetHeight(self.this,arg0)
-        return val
-    def GetPosition(self):
-        val = miscc.wxRect_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetSize(self):
-        val = miscc.wxRect_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetLeft(self):
-        val = miscc.wxRect_GetLeft(self.this)
-        return val
-    def GetTop(self):
-        val = miscc.wxRect_GetTop(self.this)
-        return val
-    def GetBottom(self):
-        val = miscc.wxRect_GetBottom(self.this)
-        return val
-    def GetRight(self):
-        val = miscc.wxRect_GetRight(self.this)
-        return val
-    def __setattr__(self,name,value):
-        if name == "x" :
-            miscc.wxRect_x_set(self.this,value)
-            return
-        if name == "y" :
-            miscc.wxRect_y_set(self.this,value)
-            return
-        if name == "width" :
-            miscc.wxRect_width_set(self.this,value)
-            return
-        if name == "height" :
-            miscc.wxRect_height_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "x" : 
-            return miscc.wxRect_x_get(self.this)
-        if name == "y" : 
-            return miscc.wxRect_y_get(self.this)
-        if name == "width" : 
-            return miscc.wxRect_width_get(self.this)
-        if name == "height" : 
-            return miscc.wxRect_height_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxRect instance>"
-class wxRect(wxRectPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxRect,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPyTimerPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxPyTimer(self.this)
-    def Interval(self):
-        val = miscc.wxPyTimer_Interval(self.this)
-        return val
-    def Start(self,*args):
-        val = apply(miscc.wxPyTimer_Start,(self.this,)+args)
-        return val
-    def Stop(self):
-        val = miscc.wxPyTimer_Stop(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPyTimer instance>"
-class wxPyTimer(wxPyTimerPtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxPyTimer(arg0)
-        self.thisown = 1
-
-
-
-
-class wxIndividualLayoutConstraintPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Above(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Above,(self.this,arg0.this,)+args)
-        return val
-    def Absolute(self,arg0):
-        val = miscc.wxIndividualLayoutConstraint_Absolute(self.this,arg0)
-        return val
-    def AsIs(self):
-        val = miscc.wxIndividualLayoutConstraint_AsIs(self.this)
-        return val
-    def Below(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Below,(self.this,arg0.this,)+args)
-        return val
-    def Unconstrained(self):
-        val = miscc.wxIndividualLayoutConstraint_Unconstrained(self.this)
-        return val
-    def LeftOf(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_LeftOf,(self.this,arg0.this,)+args)
-        return val
-    def PercentOf(self,arg0,arg1,arg2):
-        val = miscc.wxIndividualLayoutConstraint_PercentOf(self.this,arg0.this,arg1,arg2)
-        return val
-    def RightOf(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_RightOf,(self.this,arg0.this,)+args)
-        return val
-    def SameAs(self,arg0,arg1,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_SameAs,(self.this,arg0.this,arg1,)+args)
-        return val
-    def Set(self,arg0,arg1,arg2,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Set,(self.this,arg0,arg1.this,arg2,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxIndividualLayoutConstraint instance>"
-class wxIndividualLayoutConstraint(wxIndividualLayoutConstraintPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxLayoutConstraintsPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __setattr__(self,name,value):
-        if name == "bottom" :
-            miscc.wxLayoutConstraints_bottom_set(self.this,value.this)
-            return
-        if name == "centreX" :
-            miscc.wxLayoutConstraints_centreX_set(self.this,value.this)
-            return
-        if name == "centreY" :
-            miscc.wxLayoutConstraints_centreY_set(self.this,value.this)
-            return
-        if name == "height" :
-            miscc.wxLayoutConstraints_height_set(self.this,value.this)
-            return
-        if name == "left" :
-            miscc.wxLayoutConstraints_left_set(self.this,value.this)
-            return
-        if name == "right" :
-            miscc.wxLayoutConstraints_right_set(self.this,value.this)
-            return
-        if name == "top" :
-            miscc.wxLayoutConstraints_top_set(self.this,value.this)
-            return
-        if name == "width" :
-            miscc.wxLayoutConstraints_width_set(self.this,value.this)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "bottom" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_bottom_get(self.this))
-        if name == "centreX" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreX_get(self.this))
-        if name == "centreY" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreY_get(self.this))
-        if name == "height" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_height_get(self.this))
-        if name == "left" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_left_get(self.this))
-        if name == "right" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_right_get(self.this))
-        if name == "top" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_top_get(self.this))
-        if name == "width" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_width_get(self.this))
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxLayoutConstraints instance>"
-class wxLayoutConstraints(wxLayoutConstraintsPtr):
-    def __init__(self) :
-        self.this = miscc.new_wxLayoutConstraints()
-        self.thisown = 1
-
-
-
-
-class wxRegionPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRegion(self.this)
-    def Clear(self):
-        val = miscc.wxRegion_Clear(self.this)
-        return val
-    def Contains(self,arg0,arg1):
-        val = miscc.wxRegion_Contains(self.this,arg0,arg1)
-        return val
-    def ContainsPoint(self,arg0):
-        val = miscc.wxRegion_ContainsPoint(self.this,arg0.this)
-        return val
-    def ContainsRect(self,arg0):
-        val = miscc.wxRegion_ContainsRect(self.this,arg0.this)
-        return val
-    def GetBox(self):
-        val = miscc.wxRegion_GetBox(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def Intersect(self,arg0):
-        val = miscc.wxRegion_Intersect(self.this,arg0.this)
-        return val
-    def Subtract(self,arg0):
-        val = miscc.wxRegion_Subtract(self.this,arg0.this)
-        return val
-    def Union(self,arg0):
-        val = miscc.wxRegion_Union(self.this,arg0.this)
-        return val
-    def Xor(self,arg0):
-        val = miscc.wxRegion_Xor(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxRegion instance>"
-class wxRegion(wxRegionPtr):
-    def __init__(self) :
-        self.this = miscc.new_wxRegion()
-        self.thisown = 1
-
-
-
-
-class wxRegionIteratorPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRegionIterator(self.this)
-    def GetX(self):
-        val = miscc.wxRegionIterator_GetX(self.this)
-        return val
-    def GetY(self):
-        val = miscc.wxRegionIterator_GetY(self.this)
-        return val
-    def GetW(self):
-        val = miscc.wxRegionIterator_GetW(self.this)
-        return val
-    def GetWidth(self):
-        val = miscc.wxRegionIterator_GetWidth(self.this)
-        return val
-    def GetH(self):
-        val = miscc.wxRegionIterator_GetH(self.this)
-        return val
-    def GetHeight(self):
-        val = miscc.wxRegionIterator_GetHeight(self.this)
-        return val
-    def GetRect(self):
-        val = miscc.wxRegionIterator_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def HaveRects(self):
-        val = miscc.wxRegionIterator_HaveRects(self.this)
-        return val
-    def Reset(self):
-        val = miscc.wxRegionIterator_Reset(self.this)
-        return val
-    def Next(self):
-        val = miscc.wxRegionIterator_Next(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxRegionIterator instance>"
-class wxRegionIterator(wxRegionIteratorPtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxRegionIterator(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxAcceleratorEntryPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Set(self,arg0,arg1,arg2):
-        val = miscc.wxAcceleratorEntry_Set(self.this,arg0,arg1,arg2)
-        return val
-    def GetFlags(self):
-        val = miscc.wxAcceleratorEntry_GetFlags(self.this)
-        return val
-    def GetKeyCode(self):
-        val = miscc.wxAcceleratorEntry_GetKeyCode(self.this)
-        return val
-    def GetCommand(self):
-        val = miscc.wxAcceleratorEntry_GetCommand(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxAcceleratorEntry instance>"
-class wxAcceleratorEntry(wxAcceleratorEntryPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxAcceleratorEntry,()+args)
-        self.thisown = 1
-
-
-
-
-class wxAcceleratorTablePtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxAcceleratorTable instance>"
-class wxAcceleratorTable(wxAcceleratorTablePtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxAcceleratorTable(arg0.this)
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-def wxFileSelector(arg0,*args):
-    argl = map(None,args)
-    try: argl[5] = argl[5].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxFileSelector,(arg0,)+args)
-    return val
-
-def wxGetTextFromUser(arg0,*args):
-    argl = map(None,args)
-    try: argl[2] = argl[2].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetTextFromUser,(arg0,)+args)
-    return val
-
-def wxGetSingleChoice(arg0,arg1,arg2,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetSingleChoice,(arg0,arg1,arg2,)+args)
-    return val
-
-def wxGetSingleChoiceIndex(arg0,arg1,arg2,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetSingleChoiceIndex,(arg0,arg1,arg2,)+args)
-    return val
-
-def wxMessageBox(arg0,*args):
-    argl = map(None,args)
-    try: argl[2] = argl[2].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxMessageBox,(arg0,)+args)
-    return val
-
-wxColourDisplay = miscc.wxColourDisplay
-
-wxDisplayDepth = miscc.wxDisplayDepth
-
-def wxSetCursor(arg0):
-    val = miscc.wxSetCursor(arg0.this)
-    return val
-
-NewId = miscc.NewId
-
-RegisterId = miscc.RegisterId
-
-def wxBeginBusyCursor(*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxBeginBusyCursor,()+args)
-    return val
-
-wxBell = miscc.wxBell
-
-wxDisplaySize = miscc.wxDisplaySize
-
-wxEndBusyCursor = miscc.wxEndBusyCursor
-
-wxExecute = miscc.wxExecute
-
-def wxFindWindowByLabel(arg0,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxFindWindowByLabel,(arg0,)+args)
-    val = wxWindowPtr(val)
-    return val
-
-def wxFindWindowByName(arg0,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxFindWindowByName,(arg0,)+args)
-    val = wxWindowPtr(val)
-    return val
-
-wxGetMousePosition = miscc.wxGetMousePosition
-
-wxIsBusy = miscc.wxIsBusy
-
-wxNow = miscc.wxNow
-
-wxYield = miscc.wxYield
-
-wxGetResource = miscc.wxGetResource
-
-wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
-
-wxResourceClear = miscc.wxResourceClear
-
-def wxResourceCreateBitmap(arg0):
-    val = miscc.wxResourceCreateBitmap(arg0)
-    val = wxBitmapPtr(val)
-    val.thisown = 1
-    return val
-
-def wxResourceCreateIcon(arg0):
-    val = miscc.wxResourceCreateIcon(arg0)
-    val = wxIconPtr(val)
-    val.thisown = 1
-    return val
-
-def wxResourceCreateMenuBar(arg0):
-    val = miscc.wxResourceCreateMenuBar(arg0)
-    val = wxMenuBarPtr(val)
-    return val
-
-wxResourceGetIdentifier = miscc.wxResourceGetIdentifier
-
-wxResourceParseData = miscc.wxResourceParseData
-
-wxResourceParseFile = miscc.wxResourceParseFile
-
-wxResourceParseString = miscc.wxResourceParseString
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-wxLeft = miscc.wxLeft
-wxTop = miscc.wxTop
-wxRight = miscc.wxRight
-wxBottom = miscc.wxBottom
-wxWidth = miscc.wxWidth
-wxHeight = miscc.wxHeight
-wxCentre = miscc.wxCentre
-wxCenter = miscc.wxCenter
-wxCentreX = miscc.wxCentreX
-wxCentreY = miscc.wxCentreY
-wxUnconstrained = miscc.wxUnconstrained
-wxAsIs = miscc.wxAsIs
-wxPercentOf = miscc.wxPercentOf
-wxAbove = miscc.wxAbove
-wxBelow = miscc.wxBelow
-wxLeftOf = miscc.wxLeftOf
-wxRightOf = miscc.wxRightOf
-wxSameAs = miscc.wxSameAs
-wxAbsolute = miscc.wxAbsolute
-wxOutRegion = miscc.wxOutRegion
-wxPartRegion = miscc.wxPartRegion
-wxInRegion = miscc.wxInRegion

utils/wxPython/src/gtk/stattool.py

@@ -1,230 +0,0 @@
-# This file was created automatically by SWIG.
-import stattoolc
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from controls import *
-
-from events import *
-import wx
-class wxStatusBarPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetFieldRect(self,arg0):
-        val = stattoolc.wxStatusBar_GetFieldRect(self.this,arg0)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def GetFieldsCount(self):
-        val = stattoolc.wxStatusBar_GetFieldsCount(self.this)
-        return val
-    def GetStatusText(self,*args):
-        val = apply(stattoolc.wxStatusBar_GetStatusText,(self.this,)+args)
-        return val
-    def DrawField(self,arg0,arg1):
-        val = stattoolc.wxStatusBar_DrawField(self.this,arg0.this,arg1)
-        return val
-    def DrawFieldText(self,arg0,arg1):
-        val = stattoolc.wxStatusBar_DrawFieldText(self.this,arg0.this,arg1)
-        return val
-    def InitColours(self):
-        val = stattoolc.wxStatusBar_InitColours(self.this)
-        return val
-    def SetFieldsCount(self,*args):
-        val = apply(stattoolc.wxStatusBar_SetFieldsCount,(self.this,)+args)
-        return val
-    def SetStatusText(self,arg0,*args):
-        val = apply(stattoolc.wxStatusBar_SetStatusText,(self.this,arg0,)+args)
-        return val
-    def SetStatusWidths(self,arg0,*args):
-        val = apply(stattoolc.wxStatusBar_SetStatusWidths,(self.this,arg0,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxStatusBar instance>"
-class wxStatusBar(wxStatusBarPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(stattoolc.new_wxStatusBar,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxToolBarToolPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            stattoolc.delete_wxToolBarTool(self.this)
-    def __setattr__(self,name,value):
-        if name == "m_toolStyle" :
-            stattoolc.wxToolBarTool_m_toolStyle_set(self.this,value)
-            return
-        if name == "m_clientData" :
-            stattoolc.wxToolBarTool_m_clientData_set(self.this,value)
-            return
-        if name == "m_index" :
-            stattoolc.wxToolBarTool_m_index_set(self.this,value)
-            return
-        if name == "m_toggleState" :
-            stattoolc.wxToolBarTool_m_toggleState_set(self.this,value)
-            return
-        if name == "m_isToggle" :
-            stattoolc.wxToolBarTool_m_isToggle_set(self.this,value)
-            return
-        if name == "m_deleteSecondBitmap" :
-            stattoolc.wxToolBarTool_m_deleteSecondBitmap_set(self.this,value)
-            return
-        if name == "m_enabled" :
-            stattoolc.wxToolBarTool_m_enabled_set(self.this,value)
-            return
-        if name == "m_bitmap1" :
-            stattoolc.wxToolBarTool_m_bitmap1_set(self.this,value.this)
-            return
-        if name == "m_bitmap2" :
-            stattoolc.wxToolBarTool_m_bitmap2_set(self.this,value.this)
-            return
-        if name == "m_isMenuCommand" :
-            stattoolc.wxToolBarTool_m_isMenuCommand_set(self.this,value)
-            return
-        if name == "m_shortHelpString" :
-            stattoolc.wxToolBarTool_m_shortHelpString_set(self.this,value)
-            return
-        if name == "m_longHelpString" :
-            stattoolc.wxToolBarTool_m_longHelpString_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_toolStyle" : 
-            return stattoolc.wxToolBarTool_m_toolStyle_get(self.this)
-        if name == "m_clientData" : 
-            return stattoolc.wxToolBarTool_m_clientData_get(self.this)
-        if name == "m_index" : 
-            return stattoolc.wxToolBarTool_m_index_get(self.this)
-        if name == "m_toggleState" : 
-            return stattoolc.wxToolBarTool_m_toggleState_get(self.this)
-        if name == "m_isToggle" : 
-            return stattoolc.wxToolBarTool_m_isToggle_get(self.this)
-        if name == "m_deleteSecondBitmap" : 
-            return stattoolc.wxToolBarTool_m_deleteSecondBitmap_get(self.this)
-        if name == "m_enabled" : 
-            return stattoolc.wxToolBarTool_m_enabled_get(self.this)
-        if name == "m_bitmap1" : 
-            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap1_get(self.this))
-        if name == "m_bitmap2" : 
-            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap2_get(self.this))
-        if name == "m_isMenuCommand" : 
-            return stattoolc.wxToolBarTool_m_isMenuCommand_get(self.this)
-        if name == "m_shortHelpString" : 
-            return stattoolc.wxToolBarTool_m_shortHelpString_get(self.this)
-        if name == "m_longHelpString" : 
-            return stattoolc.wxToolBarTool_m_longHelpString_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxToolBarTool instance>"
-class wxToolBarTool(wxToolBarToolPtr):
-    def __init__(self) :
-        self.this = stattoolc.new_wxToolBarTool()
-        self.thisown = 1
-
-
-
-
-class wxToolBarPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def AddSeparator(self):
-        val = stattoolc.wxToolBar_AddSeparator(self.this)
-        return val
-    def AddTool(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(stattoolc.wxToolBar_AddTool,(self.this,arg0,arg1.this,)+args)
-        val = wxToolBarToolPtr(val)
-        return val
-    def AddSimpleTool(self,arg0,arg1,*args):
-        val = apply(stattoolc.wxToolBar_AddSimpleTool,(self.this,arg0,arg1.this,)+args)
-        val = wxToolBarToolPtr(val)
-        return val
-    def EnableTool(self,arg0,arg1):
-        val = stattoolc.wxToolBar_EnableTool(self.this,arg0,arg1)
-        return val
-    def GetToolEnabled(self,arg0):
-        val = stattoolc.wxToolBar_GetToolEnabled(self.this,arg0)
-        return val
-    def GetToolLongHelp(self,arg0):
-        val = stattoolc.wxToolBar_GetToolLongHelp(self.this,arg0)
-        return val
-    def GetToolPacking(self):
-        val = stattoolc.wxToolBar_GetToolPacking(self.this)
-        return val
-    def GetToolSeparation(self):
-        val = stattoolc.wxToolBar_GetToolSeparation(self.this)
-        return val
-    def GetToolShortHelp(self,arg0):
-        val = stattoolc.wxToolBar_GetToolShortHelp(self.this,arg0)
-        return val
-    def GetToolState(self,arg0):
-        val = stattoolc.wxToolBar_GetToolState(self.this,arg0)
-        return val
-    def Realize(self):
-        val = stattoolc.wxToolBar_Realize(self.this)
-        return val
-    def SetToolLongHelp(self,arg0,arg1):
-        val = stattoolc.wxToolBar_SetToolLongHelp(self.this,arg0,arg1)
-        return val
-    def SetToolShortHelp(self,arg0,arg1):
-        val = stattoolc.wxToolBar_SetToolShortHelp(self.this,arg0,arg1)
-        return val
-    def SetMargins(self,arg0):
-        val = stattoolc.wxToolBar_SetMargins(self.this,arg0.this)
-        return val
-    def SetToolPacking(self,arg0):
-        val = stattoolc.wxToolBar_SetToolPacking(self.this,arg0)
-        return val
-    def SetToolSeparation(self,arg0):
-        val = stattoolc.wxToolBar_SetToolSeparation(self.this,arg0)
-        return val
-    def ToggleTool(self,arg0,arg1):
-        val = stattoolc.wxToolBar_ToggleTool(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxToolBar instance>"
-class wxToolBar(wxToolBarPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(stattoolc.new_wxToolBar,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/utils.py

@@ -1,114 +0,0 @@
-# This file was created automatically by SWIG.
-import utilsc
-class wxConfigPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            utilsc.delete_wxConfig(self.this)
-    def DontCreateOnDemand(self):
-        val = utilsc.wxConfig_DontCreateOnDemand(self.this)
-        return val
-    def DeleteEntry(self,arg0,*args):
-        val = apply(utilsc.wxConfig_DeleteEntry,(self.this,arg0,)+args)
-        return val
-    def DeleteGroup(self,arg0):
-        val = utilsc.wxConfig_DeleteGroup(self.this,arg0)
-        return val
-    def Exists(self,arg0):
-        val = utilsc.wxConfig_Exists(self.this,arg0)
-        return val
-    def Flush(self,*args):
-        val = apply(utilsc.wxConfig_Flush,(self.this,)+args)
-        return val
-    def GetAppName(self):
-        val = utilsc.wxConfig_GetAppName(self.this)
-        return val
-    def GetFirstGroup(self):
-        val = utilsc.wxConfig_GetFirstGroup(self.this)
-        return val
-    def GetFirstEntry(self):
-        val = utilsc.wxConfig_GetFirstEntry(self.this)
-        return val
-    def GetNextGroup(self,arg0):
-        val = utilsc.wxConfig_GetNextGroup(self.this,arg0)
-        return val
-    def GetNextEntry(self,arg0):
-        val = utilsc.wxConfig_GetNextEntry(self.this,arg0)
-        return val
-    def GetNumberOfEntries(self,*args):
-        val = apply(utilsc.wxConfig_GetNumberOfEntries,(self.this,)+args)
-        return val
-    def GetNumberOfGroups(self,*args):
-        val = apply(utilsc.wxConfig_GetNumberOfGroups,(self.this,)+args)
-        return val
-    def GetPath(self):
-        val = utilsc.wxConfig_GetPath(self.this)
-        return val
-    def GetVendorName(self):
-        val = utilsc.wxConfig_GetVendorName(self.this)
-        return val
-    def HasEntry(self,arg0):
-        val = utilsc.wxConfig_HasEntry(self.this,arg0)
-        return val
-    def HasGroup(self,arg0):
-        val = utilsc.wxConfig_HasGroup(self.this,arg0)
-        return val
-    def IsExpandingEnvVars(self):
-        val = utilsc.wxConfig_IsExpandingEnvVars(self.this)
-        return val
-    def IsRecordingDefaults(self):
-        val = utilsc.wxConfig_IsRecordingDefaults(self.this)
-        return val
-    def Read(self,arg0,*args):
-        val = apply(utilsc.wxConfig_Read,(self.this,arg0,)+args)
-        return val
-    def ReadInt(self,arg0,*args):
-        val = apply(utilsc.wxConfig_ReadInt,(self.this,arg0,)+args)
-        return val
-    def ReadFloat(self,arg0,*args):
-        val = apply(utilsc.wxConfig_ReadFloat,(self.this,arg0,)+args)
-        return val
-    def SetAppName(self,arg0):
-        val = utilsc.wxConfig_SetAppName(self.this,arg0)
-        return val
-    def SetExpandEnvVars(self,*args):
-        val = apply(utilsc.wxConfig_SetExpandEnvVars,(self.this,)+args)
-        return val
-    def SetPath(self,arg0):
-        val = utilsc.wxConfig_SetPath(self.this,arg0)
-        return val
-    def SetRecordDefaults(self,*args):
-        val = apply(utilsc.wxConfig_SetRecordDefaults,(self.this,)+args)
-        return val
-    def SetVendorName(self,arg0):
-        val = utilsc.wxConfig_SetVendorName(self.this,arg0)
-        return val
-    def Write(self,arg0,arg1):
-        val = utilsc.wxConfig_Write(self.this,arg0,arg1)
-        return val
-    def WriteInt(self,arg0,arg1):
-        val = utilsc.wxConfig_WriteInt(self.this,arg0,arg1)
-        return val
-    def WriteFloat(self,arg0,arg1):
-        val = utilsc.wxConfig_WriteFloat(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxConfig instance>"
-class wxConfig(wxConfigPtr):
-    def __init__(self,*args) :
-        self.this = apply(utilsc.new_wxConfig,()+args)
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/windows.py

@@ -1,627 +0,0 @@
-# This file was created automatically by SWIG.
-import windowsc
-
-from misc import *
-
-from gdi import *
-import wx
-
-def wxDLG_PNT(win, point):
-    return win.ConvertDialogPointToPixels(point)
-
-def wxDLG_SZE(win, size):
-    return win.ConvertDialogPointToPixels(size)
-
-class wxEvtHandlerPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Connect(self,arg0,arg1,arg2,arg3):
-        val = windowsc.wxEvtHandler_Connect(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def __repr__(self):
-        return "<C wxEvtHandler instance>"
-class wxEvtHandler(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxWindowPtr(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def CaptureMouse(self):
-        val = windowsc.wxWindow_CaptureMouse(self.this)
-        return val
-    def Center(self,*args):
-        val = apply(windowsc.wxWindow_Center,(self.this,)+args)
-        return val
-    def Centre(self,*args):
-        val = apply(windowsc.wxWindow_Centre,(self.this,)+args)
-        return val
-    def ClientToScreen(self,arg0,arg1):
-        val = windowsc.wxWindow_ClientToScreen(self.this,arg0,arg1)
-        return val
-    def Close(self,*args):
-        val = apply(windowsc.wxWindow_Close,(self.this,)+args)
-        return val
-    def Destroy(self):
-        val = windowsc.wxWindow_Destroy(self.this)
-        return val
-    def DestroyChildren(self):
-        val = windowsc.wxWindow_DestroyChildren(self.this)
-        return val
-    def Enable(self,arg0):
-        val = windowsc.wxWindow_Enable(self.this,arg0)
-        return val
-    def FindWindowByID(self,arg0):
-        val = windowsc.wxWindow_FindWindowByID(self.this,arg0)
-        val = wxWindowPtr(val)
-        return val
-    def FindWindowByName(self,arg0):
-        val = windowsc.wxWindow_FindWindowByName(self.this,arg0)
-        val = wxWindowPtr(val)
-        return val
-    def Fit(self):
-        val = windowsc.wxWindow_Fit(self.this)
-        return val
-    def GetBackgroundColour(self):
-        val = windowsc.wxWindow_GetBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def GetCharHeight(self):
-        val = windowsc.wxWindow_GetCharHeight(self.this)
-        return val
-    def GetCharWidth(self):
-        val = windowsc.wxWindow_GetCharWidth(self.this)
-        return val
-    def GetClientSizeTuple(self):
-        val = windowsc.wxWindow_GetClientSizeTuple(self.this)
-        return val
-    def GetClientSize(self):
-        val = windowsc.wxWindow_GetClientSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetConstraints(self):
-        val = windowsc.wxWindow_GetConstraints(self.this)
-        val = wxLayoutConstraintsPtr(val)
-        return val
-    def GetFont(self):
-        val = windowsc.wxWindow_GetFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetForegroundColour(self):
-        val = windowsc.wxWindow_GetForegroundColour(self.this)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def GetGrandParent(self):
-        val = windowsc.wxWindow_GetGrandParent(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def GetId(self):
-        val = windowsc.wxWindow_GetId(self.this)
-        return val
-    def GetLabel(self):
-        val = windowsc.wxWindow_GetLabel(self.this)
-        return val
-    def GetName(self):
-        val = windowsc.wxWindow_GetName(self.this)
-        return val
-    def GetParent(self):
-        val = windowsc.wxWindow_GetParent(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def GetPositionTuple(self):
-        val = windowsc.wxWindow_GetPositionTuple(self.this)
-        return val
-    def GetPosition(self):
-        val = windowsc.wxWindow_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetRect(self):
-        val = windowsc.wxWindow_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def GetReturnCode(self):
-        val = windowsc.wxWindow_GetReturnCode(self.this)
-        return val
-    def GetScrollThumb(self,arg0):
-        val = windowsc.wxWindow_GetScrollThumb(self.this,arg0)
-        return val
-    def GetScrollPos(self,arg0):
-        val = windowsc.wxWindow_GetScrollPos(self.this,arg0)
-        return val
-    def GetScrollRange(self,arg0):
-        val = windowsc.wxWindow_GetScrollRange(self.this,arg0)
-        return val
-    def GetSizeTuple(self):
-        val = windowsc.wxWindow_GetSizeTuple(self.this)
-        return val
-    def GetSize(self):
-        val = windowsc.wxWindow_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetTextExtent(self,arg0):
-        val = windowsc.wxWindow_GetTextExtent(self.this,arg0)
-        return val
-    def GetTitle(self):
-        val = windowsc.wxWindow_GetTitle(self.this)
-        return val
-    def GetWindowStyleFlag(self):
-        val = windowsc.wxWindow_GetWindowStyleFlag(self.this)
-        return val
-    def InitDialog(self):
-        val = windowsc.wxWindow_InitDialog(self.this)
-        return val
-    def IsEnabled(self):
-        val = windowsc.wxWindow_IsEnabled(self.this)
-        return val
-    def IsRetained(self):
-        val = windowsc.wxWindow_IsRetained(self.this)
-        return val
-    def IsShown(self):
-        val = windowsc.wxWindow_IsShown(self.this)
-        return val
-    def Layout(self):
-        val = windowsc.wxWindow_Layout(self.this)
-        return val
-    def LoadFromResource(self,arg0,arg1,*args):
-        val = apply(windowsc.wxWindow_LoadFromResource,(self.this,arg0.this,arg1,)+args)
-        return val
-    def Lower(self):
-        val = windowsc.wxWindow_Lower(self.this)
-        return val
-    def MakeModal(self,arg0):
-        val = windowsc.wxWindow_MakeModal(self.this,arg0)
-        return val
-    def Move(self,arg0,arg1):
-        val = windowsc.wxWindow_Move(self.this,arg0,arg1)
-        return val
-    def PopupMenu(self,arg0,arg1,arg2):
-        val = windowsc.wxWindow_PopupMenu(self.this,arg0.this,arg1,arg2)
-        return val
-    def Raise(self):
-        val = windowsc.wxWindow_Raise(self.this)
-        return val
-    def Refresh(self,*args):
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windowsc.wxWindow_Refresh,(self.this,)+args)
-        return val
-    def ReleaseMouse(self):
-        val = windowsc.wxWindow_ReleaseMouse(self.this)
-        return val
-    def ScreenToClient(self,arg0,arg1):
-        val = windowsc.wxWindow_ScreenToClient(self.this,arg0,arg1)
-        return val
-    def ScrollWindow(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windowsc.wxWindow_ScrollWindow,(self.this,arg0,arg1,)+args)
-        return val
-    def SetAcceleratorTable(self,arg0):
-        val = windowsc.wxWindow_SetAcceleratorTable(self.this,arg0.this)
-        return val
-    def SetAutoLayout(self,arg0):
-        val = windowsc.wxWindow_SetAutoLayout(self.this,arg0)
-        return val
-    def SetBackgroundColour(self,arg0):
-        val = windowsc.wxWindow_SetBackgroundColour(self.this,arg0.this)
-        return val
-    def SetConstraints(self,arg0):
-        val = windowsc.wxWindow_SetConstraints(self.this,arg0.this)
-        return val
-    def SetDoubleClick(self,arg0):
-        val = windowsc.wxWindow_SetDoubleClick(self.this,arg0)
-        return val
-    def SetFocus(self):
-        val = windowsc.wxWindow_SetFocus(self.this)
-        return val
-    def SetFont(self,arg0):
-        val = windowsc.wxWindow_SetFont(self.this,arg0.this)
-        return val
-    def SetForegroundColour(self,arg0):
-        val = windowsc.wxWindow_SetForegroundColour(self.this,arg0.this)
-        return val
-    def SetId(self,arg0):
-        val = windowsc.wxWindow_SetId(self.this,arg0)
-        return val
-    def SetName(self,arg0):
-        val = windowsc.wxWindow_SetName(self.this,arg0)
-        return val
-    def SetReturnCode(self,arg0):
-        val = windowsc.wxWindow_SetReturnCode(self.this,arg0)
-        return val
-    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(windowsc.wxWindow_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def SetScrollPos(self,arg0,arg1,*args):
-        val = apply(windowsc.wxWindow_SetScrollPos,(self.this,arg0,arg1,)+args)
-        return val
-    def SetDimensions(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(windowsc.wxWindow_SetDimensions,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def SetSize(self,arg0):
-        val = windowsc.wxWindow_SetSize(self.this,arg0.this)
-        return val
-    def SetPosition(self,arg0):
-        val = windowsc.wxWindow_SetPosition(self.this,arg0.this)
-        return val
-    def SetSizeHints(self,*args):
-        val = apply(windowsc.wxWindow_SetSizeHints,(self.this,)+args)
-        return val
-    def SetClientSize(self,arg0,arg1):
-        val = windowsc.wxWindow_SetClientSize(self.this,arg0,arg1)
-        return val
-    def SetCursor(self,arg0):
-        val = windowsc.wxWindow_SetCursor(self.this,arg0.this)
-        return val
-    def SetTitle(self,arg0):
-        val = windowsc.wxWindow_SetTitle(self.this,arg0)
-        return val
-    def Show(self,arg0):
-        val = windowsc.wxWindow_Show(self.this,arg0)
-        return val
-    def TransferDataFromWindow(self):
-        val = windowsc.wxWindow_TransferDataFromWindow(self.this)
-        return val
-    def TransferDataToWindow(self):
-        val = windowsc.wxWindow_TransferDataToWindow(self.this)
-        return val
-    def Validate(self):
-        val = windowsc.wxWindow_Validate(self.this)
-        return val
-    def WarpPointer(self,arg0,arg1):
-        val = windowsc.wxWindow_WarpPointer(self.this,arg0,arg1)
-        return val
-    def ConvertDialogPointToPixels(self,arg0):
-        val = windowsc.wxWindow_ConvertDialogPointToPixels(self.this,arg0.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def ConvertDialogSizeToPixels(self,arg0):
-        val = windowsc.wxWindow_ConvertDialogSizeToPixels(self.this,arg0.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def ConvertPixelPointToDialog(self,arg0):
-        val = windowsc.wxWindow_ConvertPixelPointToDialog(self.this,arg0.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def ConvertPixelSizeToDialog(self,arg0):
-        val = windowsc.wxWindow_ConvertPixelSizeToDialog(self.this,arg0.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxWindow instance>"
-class wxWindow(wxWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxPanelPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def InitDialog(self):
-        val = windowsc.wxPanel_InitDialog(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPanel instance>"
-class wxPanel(wxPanelPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxPanel,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxDialogPtr(wxPanelPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Centre(self,*args):
-        val = apply(windowsc.wxDialog_Centre,(self.this,)+args)
-        return val
-    def EndModal(self,arg0):
-        val = windowsc.wxDialog_EndModal(self.this,arg0)
-        return val
-    def GetTitle(self):
-        val = windowsc.wxDialog_GetTitle(self.this)
-        return val
-    def Iconize(self,arg0):
-        val = windowsc.wxDialog_Iconize(self.this,arg0)
-        return val
-    def IsIconized(self):
-        val = windowsc.wxDialog_IsIconized(self.this)
-        return val
-    def SetModal(self,arg0):
-        val = windowsc.wxDialog_SetModal(self.this,arg0)
-        return val
-    def IsModal(self):
-        val = windowsc.wxDialog_IsModal(self.this)
-        return val
-    def SetTitle(self,arg0):
-        val = windowsc.wxDialog_SetTitle(self.this,arg0)
-        return val
-    def Show(self,arg0):
-        val = windowsc.wxDialog_Show(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = windowsc.wxDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxDialog instance>"
-class wxDialog(wxDialogPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxDialog,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxScrolledWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def EnableScrolling(self,arg0,arg1):
-        val = windowsc.wxScrolledWindow_EnableScrolling(self.this,arg0,arg1)
-        return val
-    def GetScrollPixelsPerUnit(self):
-        val = windowsc.wxScrolledWindow_GetScrollPixelsPerUnit(self.this)
-        return val
-    def GetVirtualSize(self):
-        val = windowsc.wxScrolledWindow_GetVirtualSize(self.this)
-        return val
-    def IsRetained(self):
-        val = windowsc.wxScrolledWindow_IsRetained(self.this)
-        return val
-    def PrepareDC(self,arg0):
-        val = windowsc.wxScrolledWindow_PrepareDC(self.this,arg0.this)
-        return val
-    def Scroll(self,arg0,arg1):
-        val = windowsc.wxScrolledWindow_Scroll(self.this,arg0,arg1)
-        return val
-    def SetScrollbars(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(windowsc.wxScrolledWindow_SetScrollbars,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def ViewStart(self):
-        val = windowsc.wxScrolledWindow_ViewStart(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxScrolledWindow instance>"
-class wxScrolledWindow(wxScrolledWindowPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxScrolledWindow,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._StdOnScrollCallbacks(self)
-
-
-
-
-class wxMenuPtr(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0,arg1,*args):
-        val = apply(windowsc.wxMenu_Append,(self.this,arg0,arg1,)+args)
-        return val
-    def AppendMenu(self,arg0,arg1,arg2,*args):
-        val = apply(windowsc.wxMenu_AppendMenu,(self.this,arg0,arg1,arg2.this,)+args)
-        return val
-    def AppendSeparator(self):
-        val = windowsc.wxMenu_AppendSeparator(self.this)
-        return val
-    def Break(self):
-        val = windowsc.wxMenu_Break(self.this)
-        return val
-    def Check(self,arg0,arg1):
-        val = windowsc.wxMenu_Check(self.this,arg0,arg1)
-        return val
-    def Enable(self,arg0,arg1):
-        val = windowsc.wxMenu_Enable(self.this,arg0,arg1)
-        return val
-    def FindItem(self,arg0):
-        val = windowsc.wxMenu_FindItem(self.this,arg0)
-        return val
-    def GetTitle(self):
-        val = windowsc.wxMenu_GetTitle(self.this)
-        return val
-    def SetTitle(self,arg0):
-        val = windowsc.wxMenu_SetTitle(self.this,arg0)
-        return val
-    def FindItemForId(self,arg0):
-        val = windowsc.wxMenu_FindItemForId(self.this,arg0)
-        val = wxMenuItemPtr(val)
-        return val
-    def GetHelpString(self,arg0):
-        val = windowsc.wxMenu_GetHelpString(self.this,arg0)
-        return val
-    def GetLabel(self,arg0):
-        val = windowsc.wxMenu_GetLabel(self.this,arg0)
-        return val
-    def SetHelpString(self,arg0,arg1):
-        val = windowsc.wxMenu_SetHelpString(self.this,arg0,arg1)
-        return val
-    def IsChecked(self,arg0):
-        val = windowsc.wxMenu_IsChecked(self.this,arg0)
-        return val
-    def IsEnabled(self,arg0):
-        val = windowsc.wxMenu_IsEnabled(self.this,arg0)
-        return val
-    def SetLabel(self,arg0,arg1):
-        val = windowsc.wxMenu_SetLabel(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxMenu instance>"
-class wxMenu(wxMenuPtr):
-    def __init__(self,*args) :
-        self.this = apply(windowsc.new_wxMenu,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPyMenuPtr(wxMenuPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            windowsc.delete_wxPyMenu(self.this)
-    def __repr__(self):
-        return "<C wxPyMenu instance>"
-class wxPyMenu(wxPyMenuPtr):
-    def __init__(self,*args) :
-        self.this = apply(windowsc.new_wxPyMenu,()+args)
-        self.thisown = 1
-
-
-
-
-class wxMenuBarPtr(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0,arg1):
-        val = windowsc.wxMenuBar_Append(self.this,arg0.this,arg1)
-        return val
-    def Check(self,arg0,arg1):
-        val = windowsc.wxMenuBar_Check(self.this,arg0,arg1)
-        return val
-    def Checked(self,arg0):
-        val = windowsc.wxMenuBar_Checked(self.this,arg0)
-        return val
-    def Enable(self,arg0,arg1):
-        val = windowsc.wxMenuBar_Enable(self.this,arg0,arg1)
-        return val
-    def Enabled(self,arg0):
-        val = windowsc.wxMenuBar_Enabled(self.this,arg0)
-        return val
-    def FindMenuItem(self,arg0,arg1):
-        val = windowsc.wxMenuBar_FindMenuItem(self.this,arg0,arg1)
-        return val
-    def FindItemForId(self,arg0):
-        val = windowsc.wxMenuBar_FindItemForId(self.this,arg0)
-        val = wxMenuItemPtr(val)
-        return val
-    def GetMenuCount(self):
-        val = windowsc.wxMenuBar_GetMenuCount(self.this)
-        return val
-    def GetMenu(self,arg0):
-        val = windowsc.wxMenuBar_GetMenu(self.this,arg0)
-        val = wxMenuPtr(val)
-        return val
-    def __repr__(self):
-        return "<C wxMenuBar instance>"
-class wxMenuBar(wxMenuBarPtr):
-    def __init__(self) :
-        self.this = windowsc.new_wxMenuBar()
-        self.thisown = 1
-
-
-
-
-class wxMenuItemPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def IsSeparator(self):
-        val = windowsc.wxMenuItem_IsSeparator(self.this)
-        return val
-    def IsEnabled(self):
-        val = windowsc.wxMenuItem_IsEnabled(self.this)
-        return val
-    def IsChecked(self):
-        val = windowsc.wxMenuItem_IsChecked(self.this)
-        return val
-    def IsCheckable(self):
-        val = windowsc.wxMenuItem_IsCheckable(self.this)
-        return val
-    def GetId(self):
-        val = windowsc.wxMenuItem_GetId(self.this)
-        return val
-    def GetSubMenu(self):
-        val = windowsc.wxMenuItem_GetSubMenu(self.this)
-        val = wxMenuPtr(val)
-        return val
-    def SetName(self,arg0):
-        val = windowsc.wxMenuItem_SetName(self.this,arg0)
-        return val
-    def GetName(self):
-        val = windowsc.wxMenuItem_GetName(self.this)
-        return val
-    def GetHelp(self):
-        val = windowsc.wxMenuItem_GetHelp(self.this)
-        return val
-    def SetHelp(self,arg0):
-        val = windowsc.wxMenuItem_SetHelp(self.this,arg0)
-        return val
-    def Enable(self,*args):
-        val = apply(windowsc.wxMenuItem_Enable,(self.this,)+args)
-        return val
-    def Check(self,*args):
-        val = apply(windowsc.wxMenuItem_Check,(self.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxMenuItem instance>"
-class wxMenuItem(wxMenuItemPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/gtk/windows2.py

@@ -1,545 +0,0 @@
-# This file was created automatically by SWIG.
-import windows2c
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-
-from controls import *
-
-from events import *
-import wx
-class wxGridCellPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            windows2c.delete_wxGridCell(self.this)
-    def GetTextValue(self):
-        val = windows2c.wxGridCell_GetTextValue(self.this)
-        return val
-    def SetTextValue(self,arg0):
-        val = windows2c.wxGridCell_SetTextValue(self.this,arg0)
-        return val
-    def GetFont(self):
-        val = windows2c.wxGridCell_GetFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def SetFont(self,arg0):
-        val = windows2c.wxGridCell_SetFont(self.this,arg0.this)
-        return val
-    def GetTextColour(self):
-        val = windows2c.wxGridCell_GetTextColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def SetTextColour(self,arg0):
-        val = windows2c.wxGridCell_SetTextColour(self.this,arg0.this)
-        return val
-    def GetBackgroundColour(self):
-        val = windows2c.wxGridCell_GetBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def SetBackgroundColour(self,arg0):
-        val = windows2c.wxGridCell_SetBackgroundColour(self.this,arg0.this)
-        return val
-    def GetBackgroundBrush(self):
-        val = windows2c.wxGridCell_GetBackgroundBrush(self.this)
-        val = wxBrushPtr(val)
-        return val
-    def GetAlignment(self):
-        val = windows2c.wxGridCell_GetAlignment(self.this)
-        return val
-    def SetAlignment(self,arg0):
-        val = windows2c.wxGridCell_SetAlignment(self.this,arg0)
-        return val
-    def GetCellBitmap(self):
-        val = windows2c.wxGridCell_GetCellBitmap(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def SetCellBitmap(self,arg0):
-        val = windows2c.wxGridCell_SetCellBitmap(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxGridCell instance>"
-class wxGridCell(wxGridCellPtr):
-    def __init__(self) :
-        self.this = windows2c.new_wxGridCell()
-        self.thisown = 1
-
-
-
-
-class wxGridPtr(wxPanelPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def AdjustScrollbars(self):
-        val = windows2c.wxGrid_AdjustScrollbars(self.this)
-        return val
-    def AppendCols(self,*args):
-        val = apply(windows2c.wxGrid_AppendCols,(self.this,)+args)
-        return val
-    def AppendRows(self,*args):
-        val = apply(windows2c.wxGrid_AppendRows,(self.this,)+args)
-        return val
-    def BeginBatch(self):
-        val = windows2c.wxGrid_BeginBatch(self.this)
-        return val
-    def CellHitTest(self,arg0,arg1):
-        val = windows2c.wxGrid_CellHitTest(self.this,arg0,arg1)
-        return val
-    def CreateGrid(self,arg0,arg1,*args):
-        val = apply(windows2c.wxGrid_CreateGrid,(self.this,arg0,arg1,)+args)
-        return val
-    def CurrentCellVisible(self):
-        val = windows2c.wxGrid_CurrentCellVisible(self.this)
-        return val
-    def DeleteCols(self,*args):
-        val = apply(windows2c.wxGrid_DeleteCols,(self.this,)+args)
-        return val
-    def DeleteRows(self,*args):
-        val = apply(windows2c.wxGrid_DeleteRows,(self.this,)+args)
-        return val
-    def EndBatch(self):
-        val = windows2c.wxGrid_EndBatch(self.this)
-        return val
-    def GetBatchCount(self):
-        val = windows2c.wxGrid_GetBatchCount(self.this)
-        return val
-    def GetCell(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCell(self.this,arg0,arg1)
-        val = wxGridCellPtr(val)
-        return val
-    def GetCellAlignment(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellAlignment(self.this,arg0,arg1)
-        return val
-    def GetDefCellAlignment(self):
-        val = windows2c.wxGrid_GetDefCellAlignment(self.this)
-        return val
-    def GetCellBackgroundColour(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellBackgroundColour(self.this,arg0,arg1)
-        val = wxColourPtr(val)
-        return val
-    def GetDefCellBackgroundColour(self):
-        val = windows2c.wxGrid_GetDefCellBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetCellTextColour(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellTextColour(self.this,arg0,arg1)
-        val = wxColourPtr(val)
-        return val
-    def GetDefCellTextColour(self):
-        val = windows2c.wxGrid_GetDefCellTextColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetCellTextFont(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellTextFont(self.this,arg0,arg1)
-        val = wxFontPtr(val)
-        return val
-    def GetDefCellTextFont(self):
-        val = windows2c.wxGrid_GetDefCellTextFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetCellValue(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellValue(self.this,arg0,arg1)
-        return val
-    def GetCols(self):
-        val = windows2c.wxGrid_GetCols(self.this)
-        return val
-    def GetColumnWidth(self,arg0):
-        val = windows2c.wxGrid_GetColumnWidth(self.this,arg0)
-        return val
-    def GetCurrentRect(self):
-        val = windows2c.wxGrid_GetCurrentRect(self.this)
-        val = wxRectPtr(val)
-        return val
-    def GetCursorColumn(self):
-        val = windows2c.wxGrid_GetCursorColumn(self.this)
-        return val
-    def GetCursorRow(self):
-        val = windows2c.wxGrid_GetCursorRow(self.this)
-        return val
-    def GetEditable(self):
-        val = windows2c.wxGrid_GetEditable(self.this)
-        return val
-    def GetHorizScrollBar(self):
-        val = windows2c.wxGrid_GetHorizScrollBar(self.this)
-        val = wxScrollBarPtr(val)
-        return val
-    def GetLabelAlignment(self,arg0):
-        val = windows2c.wxGrid_GetLabelAlignment(self.this,arg0)
-        return val
-    def GetLabelBackgroundColour(self):
-        val = windows2c.wxGrid_GetLabelBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetLabelSize(self,arg0):
-        val = windows2c.wxGrid_GetLabelSize(self.this,arg0)
-        return val
-    def GetLabelTextColour(self):
-        val = windows2c.wxGrid_GetLabelTextColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetLabelTextFont(self):
-        val = windows2c.wxGrid_GetLabelTextFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetLabelValue(self,arg0,arg1):
-        val = windows2c.wxGrid_GetLabelValue(self.this,arg0,arg1)
-        return val
-    def GetRowHeight(self,arg0):
-        val = windows2c.wxGrid_GetRowHeight(self.this,arg0)
-        return val
-    def GetRows(self):
-        val = windows2c.wxGrid_GetRows(self.this)
-        return val
-    def GetScrollPosX(self):
-        val = windows2c.wxGrid_GetScrollPosX(self.this)
-        return val
-    def GetScrollPosY(self):
-        val = windows2c.wxGrid_GetScrollPosY(self.this)
-        return val
-    def GetTextItem(self):
-        val = windows2c.wxGrid_GetTextItem(self.this)
-        val = wxTextCtrlPtr(val)
-        return val
-    def GetVertScrollBar(self):
-        val = windows2c.wxGrid_GetVertScrollBar(self.this)
-        val = wxScrollBarPtr(val)
-        return val
-    def InsertCols(self,*args):
-        val = apply(windows2c.wxGrid_InsertCols,(self.this,)+args)
-        return val
-    def InsertRows(self,*args):
-        val = apply(windows2c.wxGrid_InsertRows,(self.this,)+args)
-        return val
-    def OnActivate(self,arg0):
-        val = windows2c.wxGrid_OnActivate(self.this,arg0)
-        return val
-    def SetCellAlignment(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellAlignment(self.this,arg0,arg1,arg2)
-        return val
-    def SetDefCellAlignment(self,arg0):
-        val = windows2c.wxGrid_SetDefCellAlignment(self.this,arg0)
-        return val
-    def SetCellBackgroundColour(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellBackgroundColour(self.this,arg0.this,arg1,arg2)
-        return val
-    def SetDefCellBackgroundColour(self,arg0):
-        val = windows2c.wxGrid_SetDefCellBackgroundColour(self.this,arg0.this)
-        return val
-    def SetCellTextColour(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellTextColour(self.this,arg0.this,arg1,arg2)
-        return val
-    def SetDefCellTextColour(self,arg0):
-        val = windows2c.wxGrid_SetDefCellTextColour(self.this,arg0.this)
-        return val
-    def SetCellTextFont(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellTextFont(self.this,arg0.this,arg1,arg2)
-        return val
-    def SetDefCellTextFont(self,arg0):
-        val = windows2c.wxGrid_SetDefCellTextFont(self.this,arg0.this)
-        return val
-    def SetCellValue(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellValue(self.this,arg0,arg1,arg2)
-        return val
-    def SetColumnWidth(self,arg0,arg1):
-        val = windows2c.wxGrid_SetColumnWidth(self.this,arg0,arg1)
-        return val
-    def SetDividerPen(self,arg0):
-        val = windows2c.wxGrid_SetDividerPen(self.this,arg0.this)
-        return val
-    def SetEditable(self,arg0):
-        val = windows2c.wxGrid_SetEditable(self.this,arg0)
-        return val
-    def SetGridCursor(self,arg0,arg1):
-        val = windows2c.wxGrid_SetGridCursor(self.this,arg0,arg1)
-        return val
-    def SetLabelAlignment(self,arg0,arg1):
-        val = windows2c.wxGrid_SetLabelAlignment(self.this,arg0,arg1)
-        return val
-    def SetLabelBackgroundColour(self,arg0):
-        val = windows2c.wxGrid_SetLabelBackgroundColour(self.this,arg0.this)
-        return val
-    def SetLabelSize(self,arg0,arg1):
-        val = windows2c.wxGrid_SetLabelSize(self.this,arg0,arg1)
-        return val
-    def SetLabelTextColour(self,arg0):
-        val = windows2c.wxGrid_SetLabelTextColour(self.this,arg0.this)
-        return val
-    def SetLabelTextFont(self,arg0):
-        val = windows2c.wxGrid_SetLabelTextFont(self.this,arg0.this)
-        return val
-    def SetLabelValue(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetLabelValue(self.this,arg0,arg1,arg2)
-        return val
-    def SetRowHeight(self,arg0,arg1):
-        val = windows2c.wxGrid_SetRowHeight(self.this,arg0,arg1)
-        return val
-    def UpdateDimensions(self):
-        val = windows2c.wxGrid_UpdateDimensions(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxGrid instance>"
-class wxGrid(wxGridPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxGrid,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._checkForCallback(self, 'OnSelectCell',           wxEVT_GRID_SELECT_CELL)
-        wx._checkForCallback(self, 'OnCreateCell',           wxEVT_GRID_CREATE_CELL)
-        wx._checkForCallback(self, 'OnChangeLabels',         wxEVT_GRID_CHANGE_LABELS)
-        wx._checkForCallback(self, 'OnChangeSelectionLabel', wxEVT_GRID_CHANGE_SEL_LABEL)
-        wx._checkForCallback(self, 'OnCellChange',           wxEVT_GRID_CELL_CHANGE)
-        wx._checkForCallback(self, 'OnCellLeftClick',        wxEVT_GRID_CELL_LCLICK)
-        wx._checkForCallback(self, 'OnCellRightClick',       wxEVT_GRID_CELL_RCLICK)
-        wx._checkForCallback(self, 'OnLabelLeftClick',       wxEVT_GRID_LABEL_LCLICK)
-        wx._checkForCallback(self, 'OnLabelRightClick',      wxEVT_GRID_LABEL_RCLICK)
-
-
-
-
-class wxGridEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __setattr__(self,name,value):
-        if name == "m_row" :
-            windows2c.wxGridEvent_m_row_set(self.this,value)
-            return
-        if name == "m_col" :
-            windows2c.wxGridEvent_m_col_set(self.this,value)
-            return
-        if name == "m_x" :
-            windows2c.wxGridEvent_m_x_set(self.this,value)
-            return
-        if name == "m_y" :
-            windows2c.wxGridEvent_m_y_set(self.this,value)
-            return
-        if name == "m_control" :
-            windows2c.wxGridEvent_m_control_set(self.this,value)
-            return
-        if name == "m_shift" :
-            windows2c.wxGridEvent_m_shift_set(self.this,value)
-            return
-        if name == "m_cell" :
-            windows2c.wxGridEvent_m_cell_set(self.this,value.this)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_row" : 
-            return windows2c.wxGridEvent_m_row_get(self.this)
-        if name == "m_col" : 
-            return windows2c.wxGridEvent_m_col_get(self.this)
-        if name == "m_x" : 
-            return windows2c.wxGridEvent_m_x_get(self.this)
-        if name == "m_y" : 
-            return windows2c.wxGridEvent_m_y_get(self.this)
-        if name == "m_control" : 
-            return windows2c.wxGridEvent_m_control_get(self.this)
-        if name == "m_shift" : 
-            return windows2c.wxGridEvent_m_shift_get(self.this)
-        if name == "m_cell" : 
-            return wxGridCellPtr(windows2c.wxGridEvent_m_cell_get(self.this))
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxGridEvent instance>"
-class wxGridEvent(wxGridEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxNotebookEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSelection(self):
-        val = windows2c.wxNotebookEvent_GetSelection(self.this)
-        return val
-    def GetOldSelection(self):
-        val = windows2c.wxNotebookEvent_GetOldSelection(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxNotebookEvent instance>"
-class wxNotebookEvent(wxNotebookEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxNotebookPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPageCount(self):
-        val = windows2c.wxNotebook_GetPageCount(self.this)
-        return val
-    def SetSelection(self,arg0):
-        val = windows2c.wxNotebook_SetSelection(self.this,arg0)
-        return val
-    def AdvanceSelection(self,*args):
-        val = apply(windows2c.wxNotebook_AdvanceSelection,(self.this,)+args)
-        return val
-    def GetSelection(self):
-        val = windows2c.wxNotebook_GetSelection(self.this)
-        return val
-    def SetPageText(self,arg0,arg1):
-        val = windows2c.wxNotebook_SetPageText(self.this,arg0,arg1)
-        return val
-    def GetPageText(self,arg0):
-        val = windows2c.wxNotebook_GetPageText(self.this,arg0)
-        return val
-    def SetImageList(self,arg0):
-        val = windows2c.wxNotebook_SetImageList(self.this,arg0)
-        return val
-    def GetImageList(self):
-        val = windows2c.wxNotebook_GetImageList(self.this)
-        return val
-    def GetPageImage(self,arg0):
-        val = windows2c.wxNotebook_GetPageImage(self.this,arg0)
-        return val
-    def SetPageImage(self,arg0,arg1):
-        val = windows2c.wxNotebook_SetPageImage(self.this,arg0,arg1)
-        return val
-    def GetRowCount(self):
-        val = windows2c.wxNotebook_GetRowCount(self.this)
-        return val
-    def DeletePage(self,arg0):
-        val = windows2c.wxNotebook_DeletePage(self.this,arg0)
-        return val
-    def DeleteAllPages(self):
-        val = windows2c.wxNotebook_DeleteAllPages(self.this)
-        return val
-    def AddPage(self,arg0,arg1,*args):
-        val = apply(windows2c.wxNotebook_AddPage,(self.this,arg0.this,arg1,)+args)
-        return val
-    def GetPage(self,arg0):
-        val = windows2c.wxNotebook_GetPage(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxNotebook instance>"
-class wxNotebook(wxNotebookPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxNotebook,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxSplitterWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBorderSize(self):
-        val = windows2c.wxSplitterWindow_GetBorderSize(self.this)
-        return val
-    def GetMinimumPaneSize(self):
-        val = windows2c.wxSplitterWindow_GetMinimumPaneSize(self.this)
-        return val
-    def GetSashPosition(self):
-        val = windows2c.wxSplitterWindow_GetSashPosition(self.this)
-        return val
-    def GetSashSize(self):
-        val = windows2c.wxSplitterWindow_GetSashSize(self.this)
-        return val
-    def GetSplitMode(self):
-        val = windows2c.wxSplitterWindow_GetSplitMode(self.this)
-        return val
-    def GetWindow1(self):
-        val = windows2c.wxSplitterWindow_GetWindow1(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def GetWindow2(self):
-        val = windows2c.wxSplitterWindow_GetWindow2(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def Initialize(self,arg0):
-        val = windows2c.wxSplitterWindow_Initialize(self.this,arg0.this)
-        return val
-    def IsSplit(self):
-        val = windows2c.wxSplitterWindow_IsSplit(self.this)
-        return val
-    def SetBorderSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetBorderSize(self.this,arg0)
-        return val
-    def SetSashPosition(self,arg0,*args):
-        val = apply(windows2c.wxSplitterWindow_SetSashPosition,(self.this,arg0,)+args)
-        return val
-    def SetSashSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetSashSize(self.this,arg0)
-        return val
-    def SetMinimumPaneSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetMinimumPaneSize(self.this,arg0)
-        return val
-    def SetSplitMode(self,arg0):
-        val = windows2c.wxSplitterWindow_SetSplitMode(self.this,arg0)
-        return val
-    def SplitHorizontally(self,arg0,arg1,*args):
-        val = apply(windows2c.wxSplitterWindow_SplitHorizontally,(self.this,arg0.this,arg1.this,)+args)
-        return val
-    def SplitVertically(self,arg0,arg1,*args):
-        val = apply(windows2c.wxSplitterWindow_SplitVertically,(self.this,arg0.this,arg1.this,)+args)
-        return val
-    def Unsplit(self,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows2c.wxSplitterWindow_Unsplit,(self.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxSplitterWindow instance>"
-class wxSplitterWindow(wxSplitterWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxSplitterWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-wxGRID_TEXT_CTRL = windows2c.wxGRID_TEXT_CTRL
-wxGRID_HSCROLL = windows2c.wxGRID_HSCROLL
-wxGRID_VSCROLL = windows2c.wxGRID_VSCROLL
-wxEVT_GRID_SELECT_CELL = windows2c.wxEVT_GRID_SELECT_CELL
-wxEVT_GRID_CREATE_CELL = windows2c.wxEVT_GRID_CREATE_CELL
-wxEVT_GRID_CHANGE_LABELS = windows2c.wxEVT_GRID_CHANGE_LABELS
-wxEVT_GRID_CHANGE_SEL_LABEL = windows2c.wxEVT_GRID_CHANGE_SEL_LABEL
-wxEVT_GRID_CELL_CHANGE = windows2c.wxEVT_GRID_CELL_CHANGE
-wxEVT_GRID_CELL_LCLICK = windows2c.wxEVT_GRID_CELL_LCLICK
-wxEVT_GRID_CELL_RCLICK = windows2c.wxEVT_GRID_CELL_RCLICK
-wxEVT_GRID_LABEL_LCLICK = windows2c.wxEVT_GRID_LABEL_LCLICK
-wxEVT_GRID_LABEL_RCLICK = windows2c.wxEVT_GRID_LABEL_RCLICK

utils/wxPython/src/gtk/windows3.py

@@ -1,293 +0,0 @@
-# This file was created automatically by SWIG.
-import windows3c
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-
-from windows2 import *
-
-from controls import *
-
-from events import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-import wx
-class wxSashEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetEdge(self,arg0):
-        val = windows3c.wxSashEvent_SetEdge(self.this,arg0)
-        return val
-    def GetEdge(self):
-        val = windows3c.wxSashEvent_GetEdge(self.this)
-        return val
-    def SetDragRect(self,arg0):
-        val = windows3c.wxSashEvent_SetDragRect(self.this,arg0.this)
-        return val
-    def GetDragRect(self):
-        val = windows3c.wxSashEvent_GetDragRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def SetDragStatus(self,arg0):
-        val = windows3c.wxSashEvent_SetDragStatus(self.this,arg0)
-        return val
-    def GetDragStatus(self):
-        val = windows3c.wxSashEvent_GetDragStatus(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxSashEvent instance>"
-class wxSashEvent(wxSashEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSashWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSashVisible(self,arg0):
-        val = windows3c.wxSashWindow_GetSashVisible(self.this,arg0)
-        return val
-    def GetDefaultBorderSize(self):
-        val = windows3c.wxSashWindow_GetDefaultBorderSize(self.this)
-        return val
-    def GetEdgeMargin(self,arg0):
-        val = windows3c.wxSashWindow_GetEdgeMargin(self.this,arg0)
-        return val
-    def GetExtraBorderSize(self):
-        val = windows3c.wxSashWindow_GetExtraBorderSize(self.this)
-        return val
-    def GetMaximumSizeX(self):
-        val = windows3c.wxSashWindow_GetMaximumSizeX(self.this)
-        return val
-    def GetMaximumSizeY(self):
-        val = windows3c.wxSashWindow_GetMaximumSizeY(self.this)
-        return val
-    def GetMinimumSizeX(self):
-        val = windows3c.wxSashWindow_GetMinimumSizeX(self.this)
-        return val
-    def GetMinimumSizeY(self):
-        val = windows3c.wxSashWindow_GetMinimumSizeY(self.this)
-        return val
-    def HasBorder(self,arg0):
-        val = windows3c.wxSashWindow_HasBorder(self.this,arg0)
-        return val
-    def SetDefaultBorderSize(self,arg0):
-        val = windows3c.wxSashWindow_SetDefaultBorderSize(self.this,arg0)
-        return val
-    def SetExtraBorderSize(self,arg0):
-        val = windows3c.wxSashWindow_SetExtraBorderSize(self.this,arg0)
-        return val
-    def SetMaximumSizeX(self,arg0):
-        val = windows3c.wxSashWindow_SetMaximumSizeX(self.this,arg0)
-        return val
-    def SetMaximumSizeY(self,arg0):
-        val = windows3c.wxSashWindow_SetMaximumSizeY(self.this,arg0)
-        return val
-    def SetMinimumSizeX(self,arg0):
-        val = windows3c.wxSashWindow_SetMinimumSizeX(self.this,arg0)
-        return val
-    def SetMinimumSizeY(self,arg0):
-        val = windows3c.wxSashWindow_SetMinimumSizeY(self.this,arg0)
-        return val
-    def SetSashVisible(self,arg0,arg1):
-        val = windows3c.wxSashWindow_SetSashVisible(self.this,arg0,arg1)
-        return val
-    def SetSashBorder(self,arg0,arg1):
-        val = windows3c.wxSashWindow_SetSashBorder(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxSashWindow instance>"
-class wxSashWindow(wxSashWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows3c.new_wxSashWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxQueryLayoutInfoEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetRequestedLength(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetRequestedLength(self.this,arg0)
-        return val
-    def GetRequestedLength(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetRequestedLength(self.this)
-        return val
-    def SetFlags(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetFlags(self.this,arg0)
-        return val
-    def GetFlags(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetFlags(self.this)
-        return val
-    def SetSize(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetSize(self.this,arg0.this)
-        return val
-    def GetSize(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def SetOrientation(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetOrientation(self.this,arg0)
-        return val
-    def GetOrientation(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetOrientation(self.this)
-        return val
-    def SetAlignment(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetAlignment(self.this,arg0)
-        return val
-    def GetAlignment(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetAlignment(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxQueryLayoutInfoEvent instance>"
-class wxQueryLayoutInfoEvent(wxQueryLayoutInfoEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxCalculateLayoutEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetFlags(self,arg0):
-        val = windows3c.wxCalculateLayoutEvent_SetFlags(self.this,arg0)
-        return val
-    def GetFlags(self):
-        val = windows3c.wxCalculateLayoutEvent_GetFlags(self.this)
-        return val
-    def SetRect(self,arg0):
-        val = windows3c.wxCalculateLayoutEvent_SetRect(self.this,arg0.this)
-        return val
-    def GetRect(self):
-        val = windows3c.wxCalculateLayoutEvent_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxCalculateLayoutEvent instance>"
-class wxCalculateLayoutEvent(wxCalculateLayoutEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSashLayoutWindowPtr(wxSashWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetAlignment(self):
-        val = windows3c.wxSashLayoutWindow_GetAlignment(self.this)
-        return val
-    def GetOrientation(self):
-        val = windows3c.wxSashLayoutWindow_GetOrientation(self.this)
-        return val
-    def SetAlignment(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetAlignment(self.this,arg0)
-        return val
-    def SetDefaultSize(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetDefaultSize(self.this,arg0.this)
-        return val
-    def SetOrientation(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetOrientation(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxSashLayoutWindow instance>"
-class wxSashLayoutWindow(wxSashLayoutWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows3c.new_wxSashLayoutWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._checkForCallback(self, 'OnCalculateLayout',    wxEVT_CALCULATE_LAYOUT)
-        wx._checkForCallback(self, 'OnQueryLayoutInfo',    wxEVT_QUERY_LAYOUT_INFO)
-
-
-
-
-class wxLayoutAlgorithmPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            windows3c.delete_wxLayoutAlgorithm(self.this)
-    def LayoutMDIFrame(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows3c.wxLayoutAlgorithm_LayoutMDIFrame,(self.this,arg0.this,)+args)
-        return val
-    def LayoutFrame(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows3c.wxLayoutAlgorithm_LayoutFrame,(self.this,arg0.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxLayoutAlgorithm instance>"
-class wxLayoutAlgorithm(wxLayoutAlgorithmPtr):
-    def __init__(self) :
-        self.this = windows3c.new_wxLayoutAlgorithm()
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-wxSASH_TOP = windows3c.wxSASH_TOP
-wxSASH_RIGHT = windows3c.wxSASH_RIGHT
-wxSASH_BOTTOM = windows3c.wxSASH_BOTTOM
-wxSASH_LEFT = windows3c.wxSASH_LEFT
-wxSASH_NONE = windows3c.wxSASH_NONE
-wxEVT_SASH_DRAGGED = windows3c.wxEVT_SASH_DRAGGED
-wxSW_3D = windows3c.wxSW_3D
-wxSASH_STATUS_OK = windows3c.wxSASH_STATUS_OK
-wxSASH_STATUS_OUT_OF_RANGE = windows3c.wxSASH_STATUS_OUT_OF_RANGE
-wxLAYOUT_HORIZONTAL = windows3c.wxLAYOUT_HORIZONTAL
-wxLAYOUT_VERTICAL = windows3c.wxLAYOUT_VERTICAL
-wxLAYOUT_NONE = windows3c.wxLAYOUT_NONE
-wxLAYOUT_TOP = windows3c.wxLAYOUT_TOP
-wxLAYOUT_LEFT = windows3c.wxLAYOUT_LEFT
-wxLAYOUT_RIGHT = windows3c.wxLAYOUT_RIGHT
-wxLAYOUT_BOTTOM = windows3c.wxLAYOUT_BOTTOM
-wxEVT_QUERY_LAYOUT_INFO = windows3c.wxEVT_QUERY_LAYOUT_INFO
-wxEVT_CALCULATE_LAYOUT = windows3c.wxEVT_CALCULATE_LAYOUT

utils/wxPython/src/helpers.cpp

@@ -1,680 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        helpers.cpp
-// Purpose:     Helper functions/classes for the wxPython extension module
-//
-// Author:      Robin Dunn
-//
-// Created:     7/1/97
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __WXMSW__
-#include <windows.h>
-#undef FindWindow
-#undef GetCharWidth
-#undef LoadAccelerators
-#endif
-
-#ifdef __WXGTK__
-#include "gtk/gtk.h"
-#endif
-
-#undef DEBUG
-#include <Python.h>
-#include "helpers.h"
-#include <wx/module.h>
-
-//---------------------------------------------------------------------------
-
-//wxHashTable*  wxPyWindows = NULL;
-
-
-wxPoint     wxPyDefaultPosition;        //wxDefaultPosition);
-wxSize      wxPyDefaultSize;            //wxDefaultSize);
-wxString    wxPyEmptyStr("");
-
-
-
-#ifdef __WXMSW__             // If building for win32...
-extern HINSTANCE wxhInstance;
-
-//----------------------------------------------------------------------
-// This gets run when the DLL is loaded.  We just need to save a handle.
-//----------------------------------------------------------------------
-
-BOOL WINAPI DllMain(
-    HINSTANCE   hinstDLL,    // handle to DLL module
-    DWORD       fdwReason,   // reason for calling function
-    LPVOID      lpvReserved  // reserved
-   )
-{
-    wxhInstance = hinstDLL;
-    return 1;
-}
-#endif
-
-//----------------------------------------------------------------------
-// Class for implementing the wxp main application shell.
-//----------------------------------------------------------------------
-
-wxPyApp *wxPythonApp = NULL;            // Global instance of application object
-
-
-// This one isn't acutally called...  See __wxStart()
-bool wxPyApp::OnInit(void) {
-    return false;
-}
-
-int  wxPyApp::MainLoop(void) {
-    int retval = wxApp::MainLoop();
-    AfterMainLoop();
-    return retval;
-}
-
-void wxPyApp::AfterMainLoop(void) {
-    // more stuff from wxEntry...
-
-    if (wxPythonApp->GetTopWindow()) {
-        // Forcibly delete the window.
-        if (wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxFrame)) ||
-            wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxDialog))) {
-
-            wxPythonApp->GetTopWindow()->Close(TRUE);
-            wxPythonApp->DeletePendingObjects();
-        }
-        else {
-            delete wxPythonApp->GetTopWindow();
-            wxPythonApp->SetTopWindow(NULL);
-        }
-    }
-#ifdef __WXGTK__
-      wxPythonApp->DeletePendingObjects();
-#endif
-
-    wxPythonApp->OnExit();
-    wxApp::CleanUp();
-//    delete wxPythonApp;
-}
-
-
-//---------------------------------------------------------------------
-// a few native methods to add to the module
-//----------------------------------------------------------------------
-
-
-// This is where we pick up the first part of the wxEntry functionality...
-// The rest is in __wxStart and  AfterMainLoop.  This function is called when
-// wxpc is imported.  (Before there is a wxApp object.)
-void __wxPreStart()
-{
-    // Bail out if there is already windows created.  This means that the
-    // toolkit has already been initialized, as in embedding wxPython in
-    // a C++ wxWindows app.
-    if (wxTopLevelWindows.Number() > 0)
-        return;
-
-#ifdef __WXMSW__
-    wxApp::Initialize();
-#endif
-
-#ifdef __WXGTK__
-    PyObject* sysargv = PySys_GetObject("argv");
-    int argc = PyList_Size(sysargv);
-    char** argv = new char*[argc+1];
-    int x;
-    for(x=0; x<argc; x++)
-        argv[x] = PyString_AsString(PyList_GetItem(sysargv, x));
-    argv[argc] = NULL;
-
-    gtk_set_locale();
-    gtk_init( &argc, &argv );
-    delete [] argv;
-
-    wxApp::Initialize();     // may return FALSE. Should we check?
-#endif
-
-}
-
-
-
-static char* __nullArgv[1] = { 0 };
-
-// Start the user application, user App's OnInit method is a parameter here
-PyObject* __wxStart(PyObject* /* self */, PyObject* args)
-{
-    PyObject*   onInitFunc = NULL;
-    PyObject*   arglist;
-    PyObject*   result;
-    long        bResult;
-
-
-    if (!PyArg_ParseTuple(args, "O", &onInitFunc))
-        return NULL;
-
-    if (wxTopLevelWindows.Number() > 0) {
-        PyErr_SetString(PyExc_TypeError, "Only 1 wxApp per process!");
-        return NULL;
-    }
-
-
-    // This is the next part of the wxEntry functionality...
-    wxPythonApp->argc = 0;
-    wxPythonApp->argv = __nullArgv;
-    wxPythonApp->OnInitGui();
-
-
-    // Call the Python App's OnInit function
-    arglist = PyTuple_New(0);
-    result = PyEval_CallObject(onInitFunc, arglist);
-    if (!result) {
-        PyErr_Print();
-        exit(1);
-    }
-
-    if (! PyInt_Check(result)) {
-        PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
-        return NULL;
-    }
-    bResult = PyInt_AS_LONG(result);
-    if (! bResult) {
-        wxPythonApp->DeletePendingObjects();
-        wxPythonApp->OnExit();
-        wxApp::CleanUp();
-        PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting...");
-        return NULL;
-    }
-
-#ifdef __WXGTK__
-    wxTheApp->m_initialized = (wxTopLevelWindows.Number() > 0);
-#endif
-
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-
-
-
-
-PyObject* wxPython_dict;
-PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
-{
-
-    if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
-        return NULL;
-
-    if (!PyDict_Check(wxPython_dict)) {
-        PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!");
-        return NULL;
-    }
-#ifdef __WXMOTIF__
-#define wxPlatform "__WXMOTIF__"
-#endif
-#ifdef __WXQT__
-#define wxPlatform "__WXQT__"
-#endif
-#ifdef __WXGTK__
-#define wxPlatform "__WXGTK__"
-#endif
-#if defined(__WIN32__) || defined(__WXMSW__)
-#define wxPlatform "__WXMSW__"
-#endif
-#ifdef __WXMAC__
-#define wxPlatform "__WXMAC__"
-#endif
-
-    PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
-
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-
-//---------------------------------------------------------------------------
-
-
-static
-PyObject* wxPyConstructObject(void* ptr, char* className)
-{
-    char    buff[64];               // should always be big enough...
-    char    swigptr[64];
-
-    sprintf(buff, "_%s_p", className);
-    SWIG_MakePtr(swigptr, ptr, buff);
-
-    sprintf(buff, "%sPtr", className);
-    PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
-    if (! classobj) {
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-
-    PyObject* arg = Py_BuildValue("(s)", swigptr);
-    PyObject* obj = PyInstance_New(classobj, arg, NULL);
-    Py_DECREF(arg);
-
-    return obj;
-}
-
-
-// This function is used for all events destined for Python event handlers.
-void wxPyCallback::EventThunker(wxEvent& event) {
-    wxPyCallback*   cb = (wxPyCallback*)event.m_callbackUserData;
-    PyObject*       func = cb->m_func;
-    PyObject*       result;
-    PyObject*       arg;
-    PyObject*       tuple;
-
-    arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName());
-
-    tuple = PyTuple_New(1);
-    PyTuple_SET_ITEM(tuple, 0, arg);
-    result = PyEval_CallObject(func, tuple);
-    Py_DECREF(tuple);
-    if (result) {
-        Py_DECREF(result);
-        PyErr_Clear();
-    } else {
-        PyErr_Print();
-    }
-}
-
-
-//---------------------------------------------------------------------------
-
-wxPyMenu::wxPyMenu(const wxString& title, PyObject* _func)
-    : wxMenu(title, (wxFunction)(func ? MenuCallback : NULL)), func(0) {
-
-    if (_func) {
-        func = _func;
-        Py_INCREF(func);
-    }
-}
-
-wxPyMenu::~wxPyMenu() {
-    if (func)
-        Py_DECREF(func);
-}
-
-
-void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) {
-    PyObject* evtobj  = wxPyConstructObject((void*)&evt, "wxCommandEvent");
-    PyObject* menuobj = wxPyConstructObject((void*)&menu, "wxMenu");
-    if (PyErr_Occurred()) {
-        // bail out if a problem
-        PyErr_Print();
-        return;
-    }
-    // Now call the callback...
-    PyObject* func = ((wxPyMenu*)&menu)->func;
-    PyObject* args = PyTuple_New(2);
-    PyTuple_SET_ITEM(args, 0, menuobj);
-    PyTuple_SET_ITEM(args, 1, evtobj);
-    PyObject* res  = PyEval_CallObject(func, args);
-    Py_DECREF(args);
-    Py_XDECREF(res); /* In case res is a NULL pointer */
-}
-
-
-//---------------------------------------------------------------------------
-
-wxPyTimer::wxPyTimer(PyObject* callback) {
-    func = callback;
-    Py_INCREF(func);
-}
-
-wxPyTimer::~wxPyTimer() {
-    Py_DECREF(func);
-}
-
-void wxPyTimer::Notify() {
-    PyObject*   result;
-    PyObject*   args = Py_BuildValue("()");
-
-    result = PyEval_CallObject(func, args);
-    Py_DECREF(args);
-    if (result) {
-        Py_DECREF(result);
-        PyErr_Clear();
-    } else {
-        PyErr_Print();
-    }
-}
-
-
-
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-// Some helper functions for typemaps in my_typemaps.i, so they won't be
-// imcluded in every file...
-
-
-byte* byte_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count = PyList_Size(source);
-    byte* temp = new byte[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (! PyInt_Check(o)) {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
-            return NULL;
-        }
-        temp[x] = (byte)PyInt_AsLong(o);
-    }
-    return temp;
-}
-
-
-int* int_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count = PyList_Size(source);
-    int* temp = new int[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (! PyInt_Check(o)) {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
-            return NULL;
-        }
-        temp[x] = PyInt_AsLong(o);
-    }
-    return temp;
-}
-
-
-long* long_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count = PyList_Size(source);
-    long* temp = new long[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (! PyInt_Check(o)) {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
-            return NULL;
-        }
-        temp[x] = PyInt_AsLong(o);
-    }
-    return temp;
-}
-
-
-char** string_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count = PyList_Size(source);
-    char** temp = new char*[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (! PyString_Check(o)) {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
-            return NULL;
-        }
-        temp[x] = PyString_AsString(o);
-    }
-    return temp;
-}
-
-
-
-wxPoint* wxPoint_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count = PyList_Size(source);
-    wxPoint* temp = new wxPoint[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (PyString_Check(o)) {
-            char*       st = PyString_AsString(o);
-            wxPoint*    pt;
-            if (SWIG_GetPtr(st,(void **) &pt,"_wxPoint_p")) {
-                PyErr_SetString(PyExc_TypeError,"Expected _wxPoint_p.");
-                return NULL;
-            }
-            temp[x] = *pt;
-        }
-        else if (PyTuple_Check(o)) {
-            PyObject* o1 = PyTuple_GetItem(o, 0);
-            PyObject* o2 = PyTuple_GetItem(o, 1);
-
-            temp[x].x = PyInt_AsLong(o1);
-            temp[x].y = PyInt_AsLong(o2);
-        }
-        else {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of 2-tuples or wxPoints.");
-            return NULL;
-        }
-    }
-    return temp;
-}
-
-
-wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count = PyList_Size(source);
-    wxBitmap** temp = new wxBitmap*[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (PyString_Check(o)) {
-            char*       st = PyString_AsString(o);
-            wxBitmap*    pt;
-            if (SWIG_GetPtr(st,(void **) &pt,"_wxBitmap_p")) {
-                PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
-                return NULL;
-            }
-            temp[x] = pt;
-        }
-        else {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
-            return NULL;
-        }
-    }
-    return temp;
-}
-
-
-
-wxString* wxString_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count = PyList_Size(source);
-    wxString* temp = new wxString[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (! PyString_Check(o)) {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
-            return NULL;
-        }
-        temp[x] = PyString_AsString(o);
-    }
-    return temp;
-}
-
-
-wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
-    if (!PyList_Check(source)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        return NULL;
-    }
-    int count                = PyList_Size(source);
-    wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
-    if (! temp) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* o = PyList_GetItem(source, x);
-        if (PyString_Check(o)) {
-            char*               st = PyString_AsString(o);
-            wxAcceleratorEntry* ae;
-            if (SWIG_GetPtr(st,(void **) &ae,"_wxAcceleratorEntry_p")) {
-                PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
-                return NULL;
-            }
-            temp[x] = *ae;
-        }
-        else if (PyTuple_Check(o)) {
-            PyObject* o1 = PyTuple_GetItem(o, 0);
-            PyObject* o2 = PyTuple_GetItem(o, 1);
-            PyObject* o3 = PyTuple_GetItem(o, 2);
-
-            temp[x].m_flags   = PyInt_AsLong(o1);
-            temp[x].m_keyCode = PyInt_AsLong(o2);
-            temp[x].m_command = PyInt_AsLong(o3);
-        }
-        else {
-            PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
-            return NULL;
-        }
-    }
-    return temp;
-}
-
-//----------------------------------------------------------------------
-
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.18  1999/01/30 08:17:27  RD
-// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-//
-// Various cleanup, tweaks, minor additions, etc. to maintain
-// compatibility with the current wxWindows.
-//
-// Revision 1.17  1999/01/30 07:30:12  RD
-//
-// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-//
-// Various cleanup, tweaks, minor additions, etc. to maintain
-// compatibility with the current wxWindows.
-//
-// Revision 1.16  1998/12/17 14:07:39  RR
-//
-//   Removed minor differences between wxMSW and wxGTK
-//
-// Revision 1.15  1998/12/15 20:41:19  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.14  1998/11/25 08:45:25  RD
-//
-// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
-// Added events for wxGrid
-// Other various fixes and additions
-//
-// Revision 1.13  1998/11/15 23:03:45  RD
-// Removing some ifdef's for wxGTK
-//
-// Revision 1.12  1998/11/03 09:21:08  RD
-// fixed a typo
-//
-// Revision 1.11  1998/10/20 06:43:58  RD
-// New wxTreeCtrl wrappers (untested)
-// some changes in helpers
-// etc.
-//
-// Revision 1.10  1998/10/02 06:40:39  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.9  1998/09/25 13:28:52  VZ
-//
-// USE_xxx constants renamed to wxUSE_xxx. This is an incompatible change, you
-// must recompile everything after upgrading!
-//
-// Revision 1.8  1998/08/27 21:59:08  RD
-// Some chicken-and-egg problems solved for wxPython on wxGTK
-//
-// Revision 1.7  1998/08/27 00:00:26  RD
-// - more tweaks
-// - have discovered some problems but not yet discovered solutions...
-//
-// Revision 1.6  1998/08/18 21:54:12  RD
-//
-// ifdef out some wxGTK specific code
-//
-// Revision 1.5  1998/08/18 19:48:17  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.4  1998/08/16 04:31:06  RD
-// More wxGTK work.
-//
-// Revision 1.3  1998/08/15 07:36:36  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.2  1998/08/14 23:36:36  RD
-// Beginings of wxGTK compatibility
-//
-// Revision 1.1  1998/08/09 08:25:51  RD
-// Initial version
-//
-//

utils/wxPython/src/helpers.h

@@ -1,131 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        helpers.h
-// Purpose:     Helper functions/classes for the wxPython extenaion module
-//
-// Author:      Robin Dunn
-//
-// Created:     7/1/97
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __wxp_helpers__
-#define __wxp_helpers__
-
-#include <wx/wx.h>
-
-
-//----------------------------------------------------------------------
-
-class wxPyApp: public wxApp
-{
-public:
-    int  MainLoop(void);
-    bool OnInit(void);
-    void AfterMainLoop(void);
-};
-
-extern wxPyApp *wxPythonApp;
-
-//----------------------------------------------------------------------
-
-void      __wxPreStart();
-PyObject* __wxStart(PyObject*, PyObject* args);
-
-extern PyObject* wxPython_dict;
-PyObject* __wxSetDictionary(PyObject*, PyObject* args);
-
-extern wxHashTable*  wxPyWindows;  // keep track of all windows so we
-                                   // don't accidentally delete them twice.
-
-void wxPyEventThunker(wxObject*, wxEvent& event);
-
-//----------------------------------------------------------------------
-
-
-#ifndef SWIGCODE
-extern "C" void SWIG_MakePtr(char *, void *, char *);
-extern "C" char *SWIG_GetPtr(char *, void **, char *);
-#endif
-
-
-#ifdef _MSC_VER
-# pragma warning(disable:4800)
-#endif
-
-typedef unsigned char byte;
-
-
-// Non-const versions to keep SWIG happy.
-extern wxPoint  wxPyDefaultPosition;
-extern wxSize   wxPyDefaultSize;
-extern wxString wxPyEmptyStr;
-
-//----------------------------------------------------------------------
-
-class wxPyCallback : public wxObject {
-public:
-    wxPyCallback(PyObject* func)    { m_func = func; Py_INCREF(m_func); }
-    ~wxPyCallback()                 { Py_DECREF(m_func); }
-
-    void EventThunker(wxEvent& event);
-
-    PyObject*   m_func;
-};
-
-//---------------------------------------------------------------------------
-
-class wxPyMenu : public wxMenu {
-public:
-    wxPyMenu(const wxString& title = "", PyObject* func=NULL);
-    ~wxPyMenu();
-
-private:
-    static void MenuCallback(wxMenu& menu, wxCommandEvent& evt);
-    PyObject*   func;
-};
-
-
-//---------------------------------------------------------------------------
-
-class wxPyTimer : public wxTimer {
-public:
-    wxPyTimer(PyObject* callback);
-    ~wxPyTimer();
-
-    void        Notify();
-
-private:
-    PyObject*   func;
-};
-
-//---------------------------------------------------------------------------
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.6  1998/11/25 08:45:26  RD
-// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
-// Added events for wxGrid
-// Other various fixes and additions
-//
-// Revision 1.5  1998/10/02 06:40:40  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.4  1998/08/27 21:59:09  RD
-// Some chicken-and-egg problems solved for wxPython on wxGTK
-//
-// Revision 1.3  1998/08/16 04:31:09  RD
-// More wxGTK work.
-//
-// Revision 1.2  1998/08/14 23:36:37  RD
-// Beginings of wxGTK compatibility
-//
-// Revision 1.1  1998/08/09 08:25:51  RD
-// Initial version
-//
-//
-
-#endif
-

utils/wxPython/src/makefile.nt

@@ -1,328 +0,0 @@
-#----------------------------------------------------------------------------
-# Name:		makefile.nt
-# Purpose:	Win32, VC++ 5 makefile for wxPython
-#
-# Author:       Robin Dunn
-#
-# Created:	3/27/97
-# RCS-ID:       $Id$
-# Copyright:    (c) 1998 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-VERSION=0.5.4
-
-# Set WXDIR to the root wxWindows directory for your system
-WXDIR = $(WXWIN)
-
-# Set this to the root of the Python installation
-PYTHONDIR=e:\Tools\Python15
-
-# Set this to 1 for a non-debug, optimised compile
-FINAL=0
-
-# Set this to where you want the stuff installed at.  It should
-# be a directory contained in a PYTHONPATH directory, and should be
-# named wxPython
-TARGETDIR=..
-
-# Set this to 1 for make to pre-compile the Python modules, 0 to
-# just copy the sources and let Python compile them at the first
-# runtime.
-COMPILEPY=0
-
-SEPARATE=0
-
-#----------------------------------------------------------------------
-
-WXUSINGDLL=0
-NOPCH=1
-THISDIR=$(WXDIR)\utils\wxPython
-
-EXTRALIBS=$(PYTHONDIR)\libs\python15.lib
-EXTRAINC=-I$(PYTHONDIR)\include -I.
-EXTRAFLAGS=/Fpwxp.pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H
-OVERRIDEFLAGS=/GX-
-
-
-SWIGFLAGS=-c++ -shadow -python -dnone -D__WXMSW__
-GENCODEDIR=msw
-
-
-!include $(WXDIR)\src\ntwxwin.mak
-
-#----------------------------------------------------------------------
-
-TARGET = wxc
-
-OBJECTS = wx.obj         helpers.obj    windows.obj    events.obj     \
-	  misc.obj       gdi.obj        mdi.obj        controls.obj   \
-	  controls2.obj  windows2.obj   cmndlgs.obj    stattool.obj   \
-	  frames.obj     windows3.obj \
-!if "$(SEPARATE)" == "0"
-	  utils.obj
-!else
-
-TARGET2 = utilsc
-OBJECTS2 = utils.obj
-target2=$(TARGETDIR)\$(TARGET2).pyd
-!endif
-
-PYMODULES = $(TARGETDIR)\wx.py        $(TARGETDIR)\events.py    \
-	    $(TARGETDIR)\windows.py   $(TARGETDIR)\misc.py      \
-	    $(TARGETDIR)\gdi.py       $(TARGETDIR)\mdi.py       \
-	    $(TARGETDIR)\controls.py  $(TARGETDIR)\controls2.py \
-            $(TARGETDIR)\windows2.py  $(TARGETDIR)\cmndlgs.py   \
-	    $(TARGETDIR)\stattool.py  $(TARGETDIR)\frames.py    \
-	    $(TARGETDIR)\utils.py     $(TARGETDIR)\windows3.py  \
-	    $(TARGETDIR)\__init__.py
-
-
-#----------------------------------------------------------------------
-
-!if "$(FINAL)" == "0"
-DEBUGLFLAGS = /DEBUG /INCREMENTAL:YES
-!else
-DEBUGLFLAGS = /INCREMENTAL:NO
-!endif
-
-LFLAGS= $(DEBUGLFLAGS) /DLL /def:$(TARGET).def /subsystem:windows,3.50 \
-	/machine:I386 /implib:./$(TARGET).lib /nologo
-
-LFLAGS2=$(DEBUGLFLAGS) /DLL /def:$(TARGET2).def /subsystem:windows,3.50 \
-	/machine:I386 /implib:./$(TARGET2).lib /nologo
-
-#----------------------------------------------------------------------
-
-default: $(TARGETDIR)\$(TARGET).pyd $(target2) pycfiles
-
-all:	wx $(TARGET) $(TARGET2)
-
-wx:
-        cd $(WXDIR)\src\msw
-        nmake -f makefile.nt FINAL=$(FINAL)
-        cd $(THISDIR)
-
-wxclean:
-        cd $(WXDIR)\src\msw
-        nmake -f makefile.nt clean
-        cd $(THISDIR)
-
-
-pycfiles : $(PYMODULES)
-!if "$(COMPILEPY)" == "1"
-	$(PYTHONDIR)\python $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
-	$(PYTHONDIR)\python -O $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
-!endif
-
-#----------------------------------------------------------------------
-
-$(TARGETDIR)\$(TARGET).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(TARGET).res
-	$(link) @<<
-/out:$@ /dll
-$(LFLAGS)
-$(DUMMYOBJ) $(OBJECTS) $(TARGET).res
-$(LIBS)
-<<
-
-$(TARGETDIR)\$(TARGET2).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS2)
-	$(link) @<<
-/out:$@ /dll
-$(LFLAGS2)
-$(DUMMYOBJ) $(OBJECTS2)
-$(LIBS)
-<<
-
-
-$(TARGET).res :      $(TARGET).rc $(WXDIR)\include\wx\msw\wx.rc
-    $(rc) -r /i$(WXDIR)\include -fo$@ $(TARGET).rc
-
-
-
-# implicit rule for compiling .cpp files
-{}.cpp{}.obj:
-        $(cc) @<<
-$(CPPFLAGS) /c /Tp $<
-<<
-
-{$(GENCODEDIR)}.cpp{}.obj:
-        $(cc) @<<
-$(CPPFLAGS) /c /Tp $<
-<<
-
-
-clean:
-        -erase *.obj
-        -erase *.exe
-        -erase *.res
-        -erase *.map
-        -erase *.sbr
-        -erase *.pdb
-	-erase *.pch
-	-erase $(TARGET).exp
-	-erase $(TARGET).lib
-	-erase $(TARGETDIR)\$(TARGET).*
-!if "$(SEPARATE)" != "0"
-	-erase $(TARGET2).exp
-	-erase $(TARGET2).lib
-	-erase $(TARGETDIR)\$(TARGET2).*
-!endif
-	-erase $(TARGETDIR)\$(TARGET).pyd
-	-erase $(TARGETDIR)\*.py
-	-erase $(TARGETDIR)\*.pyc
-	-erase $(TARGETDIR)\*.pyo
-
-
-
-#------------------------------------------------------------------------
-
-.SUFFIXES : .i .py
-
-# Implicit rules to run SWIG
-{}.i{$(GENCODEDIR)}.cpp:
-	swig $(SWIGFLAGS) -c -o $@ $<
-
-{}.i{$(GENCODEDIR)}.py:
-	swig $(SWIGFLAGS) -c -o $@ $<
-
-
-{$(GENCODEDIR)}.py{$(TARGETDIR)}.py:
-	copy $< $@
-
-{}.py{$(TARGETDIR)}.py:
-	copy $< $@
-
-#{}.py{$(TARGETDIR)}.$(PYEXT):
-#	$(PYTHON) -c "import py_compile; py_compile.compile('$<', '$@')"
-
-
-
-
-# This one must leave out the -c flag so we define the whole rule
-$(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py : wx.i my_typemaps.i _defs.i _extras.py
-        swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
-
-
-# Define some dependencies.  These MUST use forward slashes so SWIG
-# will write the shadow file to the right directory.
-$(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py   : windows.i    my_typemaps.i _defs.i
-$(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py  : windows2.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py  : windows3.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py    : events.i     my_typemaps.i _defs.i
-$(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py      : misc.i       my_typemaps.i _defs.i
-$(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py       : gdi.i        my_typemaps.i _defs.i
-$(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py       : mdi.i        my_typemaps.i _defs.i
-$(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py  : controls.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i  my_typemaps.i _defs.i
-$(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py   : cmndlgs.i    my_typemaps.i _defs.i
-$(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py  : stattool.i   my_typemaps.i _defs.i
-$(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py    : frames.i     my_typemaps.i _defs.i
-
-!if "$(SEPARATE)" == "1"
-$(GENCODEDIR)\utils.cpp $(GENCODEDIR)\utils.py : utils.i my_typemaps.i
-        swig $(SWIGFLAGS) -o $(GENCODEDIR)/utils.cpp utils.i
-!else
-$(GENCODEDIR)/utils.cpp    $(GENCODEDIR)/utils.py    : utils.i     my_typemaps.i _defs.i
-!endif
-
-
-$(TARGETDIR)\wx.py        : $(GENCODEDIR)\wx.py
-$(TARGETDIR)\windows.py   : $(GENCODEDIR)\windows.py
-$(TARGETDIR)\windows2.py  : $(GENCODEDIR)\windows2.py
-$(TARGETDIR)\windows3.py  : $(GENCODEDIR)\windows3.py
-$(TARGETDIR)\events.py    : $(GENCODEDIR)\events.py
-$(TARGETDIR)\misc.py      : $(GENCODEDIR)\misc.py
-$(TARGETDIR)\gdi.py       : $(GENCODEDIR)\gdi.py
-$(TARGETDIR)\mdi.py       : $(GENCODEDIR)\mdi.py
-$(TARGETDIR)\controls.py  : $(GENCODEDIR)\controls.py
-$(TARGETDIR)\controls2.py : $(GENCODEDIR)\controls2.py
-$(TARGETDIR)\cmndlgs.py   : $(GENCODEDIR)\cmndlgs.py
-$(TARGETDIR)\frames.py    : $(GENCODEDIR)\frames.py
-$(TARGETDIR)\stattool.py  : $(GENCODEDIR)\stattool.py
-$(TARGETDIR)\utils.py     : $(GENCODEDIR)\utils.py
-$(TARGETDIR)\__init__.py  : __init__.py
-
-
-SOURCES = $(GENCODEDIR)\wx.cpp        $(GENCODEDIR)\wx.py       \
-	  $(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py  \
-	  $(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py \
-	  $(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py \
-	  $(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py   \
-	  $(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py     \
-	  $(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py      \
-	  $(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py      \
-	  $(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py \
-	  $(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py\
-	  $(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py  \
-	  $(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py \
-	  $(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py   \
-	  $(GENCODEDIR)/utils.cpp     $(GENCODEDIR)/utils.py    \
-
-
-sources : $(SOURCES)
-
-
-dist:
-	cd ..\..
-	wxPython\distrib\zipit.bat $(VERSION)
-
-#------------------------------------------------------------------------
-#
-# $Log$
-# Revision 1.10  1999/02/01 00:10:40  RD
-# Added the missing EVT_LIST_ITEM_SELECTED and friends.
-#
-# Revision 1.9  1999/01/30 07:30:13  RD
-#
-# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-#
-# Various cleanup, tweaks, minor additions, etc. to maintain
-# compatibility with the current wxWindows.
-#
-# Revision 1.8  1998/12/21 19:58:06  RD
-#
-# Now compiles with /GX- on MSW.
-#
-# Revision 1.7  1998/12/15 20:41:20  RD
-# Changed the import semantics from "from wxPython import *" to "from
-# wxPython.wx import *"  This is for people who are worried about
-# namespace pollution, they can use "from wxPython import wx" and then
-# prefix all the wxPython identifiers with "wx."
-#
-# Added wxTaskbarIcon for wxMSW.
-#
-# Made the events work for wxGrid.
-#
-# Added wxConfig.
-#
-# Added wxMiniFrame for wxGTK, (untested.)
-#
-# Changed many of the args and return values that were pointers to gdi
-# objects to references to reflect changes in the wxWindows API.
-#
-# Other assorted fixes and additions.
-#
-# Revision 1.6  1998/10/02 06:40:41  RD
-#
-# Version 0.4 of wxPython for MSW.
-#
-# Revision 1.5  1998/08/19 00:38:23  RD
-#
-# A few tweaks
-#
-# Revision 1.4  1998/08/18 21:55:10  RD
-#
-# New build directory structure
-#
-# Revision 1.3  1998/08/15 07:36:37  RD
-# - Moved the header in the .i files out of the code that gets put into
-# the .cpp files.  It caused CVS conflicts because of the RCS ID being
-# different each time.
-#
-# - A few minor fixes.
-#
-# Revision 1.2  1998/08/14 03:34:23  RD
-# made pre-compiling the python files optional
-#
-# Revision 1.1  1998/08/09 08:25:51  RD
-# Initial version
-#

utils/wxPython/src/mdi.i

@@ -1,141 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        mdi.i
-// Purpose:     MDI related class definitions for wxPython
-//
-// Author:      Robin Dunn
-//
-// Created:     5/26/98
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module mdi
-
-%{
-#include "helpers.h"
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-%import misc.i
-%import windows.i
-%import frames.i
-
-%pragma(python) code = "import wx"
-
-//----------------------------------------------------------------------
-
-class wxMDIParentFrame : public wxFrame {
-public:
-    wxMDIParentFrame(wxWindow *parent,
-                     const wxWindowID id,
-                     const wxString& title,
-                     const wxPoint& pos = wxPyDefaultPosition,
-                     const wxSize& size = wxPyDefaultSize,
-                     long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
-                     const char* name = "frame");
-
-    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
-
-    void ActivateNext();
-    void ActivatePrevious();
-    void ArrangeIcons();
-    void Cascade();
-    void GetClientSize(int* OUTPUT, int* OUTPUT);
-    wxMDIChildFrame* GetActiveChild();
-    wxMDIClientWindow* GetClientWindow();
-    wxWindow* GetToolBar();
-
-    // TODO:  This isn't handled by the standard event-table system...
-    //wxMDIClientWindow* OnCreateClient();
-
-#ifdef __WXMSW__
-    void SetToolBar(wxToolBar* toolbar);
-#endif
-    void Tile();
-};
-
-//---------------------------------------------------------------------------
-
-class wxMDIChildFrame : public wxFrame {
-public:
-    wxMDIChildFrame(wxMDIParentFrame* parent,
-                    const wxWindowID id,
-                    const wxString& title,
-                    const wxPoint& pos = wxPyDefaultPosition,
-                    const wxSize& size = wxPyDefaultSize,
-                    long style = wxDEFAULT_FRAME_STYLE,
-                    const char* name = "frame");
-
-    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
-
-    void Activate();
-    void Maximize();
-    void Restore();
-
-    void SetMenuBar(wxMenuBar *menu_bar);
-    void SetClientSize(int width, int height);
-    void GetPosition(int* OUTPUT, int* OUTPUT) const ;
-
-};
-
-
-//---------------------------------------------------------------------------
-
-class wxMDIClientWindow : public wxWindow {
-public:
-    wxMDIClientWindow(wxMDIParentFrame* parent, long style = 0);
-    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
-    %pragma(python) addtomethod = "__init__:wx._StdOnScrollCallbacks(self)"
-};
-
-//---------------------------------------------------------------------------
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.5  1998/12/15 20:41:21  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.4  1998/10/02 06:40:41  RD
-//
-// Version 0.4 of wxPython for MSW.
-//
-// Revision 1.3  1998/08/18 19:48:18  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.2  1998/08/15 07:36:39  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.1  1998/08/09 08:25:51  RD
-// Initial version
-//
-//

utils/wxPython/src/misc.i

@@ -1,426 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        misc.i
-// Purpose:     Definitions of miscelaneous functions and classes
-//
-// Author:      Robin Dunn
-//
-// Created:     7/3/97
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module misc
-
-%{
-#include "helpers.h"
-#include <wx/resource.h>
-%}
-
-//----------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-// Import some definitions of other classes, etc.
-%import _defs.i
-
-//---------------------------------------------------------------------------
-
-
-
-class wxSize {
-public:
-    %name(width) long x;
-    %name(height)long y;
-
-    wxSize(long w=0, long h=0);
-    ~wxSize();
-    void Set(long w, long h);
-    %name(GetWidth) long GetX();
-    %name(GetHeight)long GetY();
-
-    %addmethods {
-        PyObject* __str__() {
-            PyObject* tup = PyTuple_New(2);
-            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
-            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
-            return tup;
-        }
-    }
-};
-
-//---------------------------------------------------------------------------
-
-class wxRealPoint {
-public:
-    double x;
-    double y;
-    wxRealPoint(double x=0.0, double y=0.0);
-    ~wxRealPoint();
-};
-
-class wxPoint {
-public:
-    long x;
-    long y;
-    wxPoint(long x=0, long y=0);
-    ~wxPoint();
-
-    %addmethods {
-        void Set(long x, long y) {
-            self->x = x;
-            self->y = y;
-        }
-        PyObject* __str__() {
-            PyObject* tup = PyTuple_New(2);
-            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
-            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
-            return tup;
-        }
-    }
-};
-
-//---------------------------------------------------------------------------
-
-class wxRect {
-public:
-   wxRect(long x=0, long y=0, long w=0, long h=0);
-   // TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
-   ~wxRect();
-
-   long  GetX();
-   void SetX(long X);
-   long  GetY();
-   void SetY(long Y);
-   long  GetWidth();
-   void SetWidth(long w);
-   long  GetHeight();
-   void SetHeight(long h);
-
-
-   wxPoint GetPosition();
-   wxSize GetSize();
-
-   long  GetLeft();
-   long  GetTop();
-   long  GetBottom();
-   long  GetRight();
-
-   long x, y, width, height;
-};
-
-
-
-//---------------------------------------------------------------------------
-// Dialog Functions
-
-wxString wxFileSelector(char* message,
-                        char* default_path = NULL,
-                        char* default_filename = NULL,
-                        char* default_extension = NULL,
-                        char* wildcard = "*.*",
-                        int flags = 0,
-                        wxWindow *parent = NULL,
-                        int x = -1, int y = -1);
-
-wxString wxGetTextFromUser(const wxString& message,
-                           const wxString& caption = wxPyEmptyStr,
-                           const wxString& default_value = wxPyEmptyStr,
-                           wxWindow *parent = NULL,
-                           int x = -1, int y = -1,
-                           bool centre = TRUE);
-
-// TODO: Need to custom wrap this one...
-// int wxGetMultipleChoice(char* message, char* caption,
-//                         int LCOUNT, char** LIST,
-//                         int nsel, int *selection,
-//                         wxWindow *parent = NULL, int x = -1, int y = -1,
-//                         bool centre = TRUE, int width=150, int height=200);
-
-
-wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
-                           int LCOUNT, wxString* LIST,
-                           wxWindow *parent = NULL,
-                           int x = -1, int y = -1,
-                           bool centre = TRUE,
-                           int width=150, int height=200);
-
-int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
-                           int LCOUNT, wxString* LIST,
-                           wxWindow *parent = NULL,
-                           int x = -1, int y = -1,
-                           bool centre = TRUE,
-                           int width=150, int height=200);
-
-
-int wxMessageBox(const wxString& message,
-                 const wxString& caption = wxPyEmptyStr,
-                 int style = wxOK | wxCENTRE,
-                 wxWindow *parent = NULL,
-                 int x = -1, int y = -1);
-
-//---------------------------------------------------------------------------
-// GDI Functions
-
-bool wxColourDisplay();
-int wxDisplayDepth();
-void wxSetCursor(wxCursor& cursor);
-
-//---------------------------------------------------------------------------
-// Miscellaneous functions
-
-long NewId();
-void RegisterId(long id);
-void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
-void wxBell();
-void wxDisplaySize(int *OUTPUT, int *OUTPUT);
-void wxEndBusyCursor();
-long wxExecute(const wxString& command, bool sync = FALSE);
-wxWindow * wxFindWindowByLabel(const wxString& label, wxWindow *parent=NULL);
-wxWindow * wxFindWindowByName(const wxString& name, wxWindow *parent=NULL);
-#ifdef __WXMSW__
-wxWindow * wxGetActiveWindow();
-long wxGetElapsedTime(bool resetTimer = TRUE);
-long wxGetFreeMemory();
-#endif
-void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
-bool wxIsBusy();
-wxString wxNow();
-#ifdef __WXMSW__
-bool wxShell(const wxString& command = wxPyEmptyStr);
-void wxStartTimer();
-int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
-#endif
-
-bool wxYield();
-
-%inline %{
-    char* wxGetResource(char *section, char *entry, char *file = NULL) {
-        char * retval;
-        wxGetResource(section, entry, &retval, file);
-        return retval;
-    }
-%}
-
-//---------------------------------------------------------------------------
-// Resource System
-
-bool wxResourceAddIdentifier(char *name, int value);
-void wxResourceClear(void);
-wxBitmap  wxResourceCreateBitmap(char *resource);
-wxIcon  wxResourceCreateIcon(char *resource);
-wxMenuBar * wxResourceCreateMenuBar(char *resource);
-int wxResourceGetIdentifier(char *name);
-bool wxResourceParseData(char *resource, wxResourceTable *table = NULL);
-bool wxResourceParseFile(char *filename, wxResourceTable *table = NULL);
-bool wxResourceParseString(char *resource, wxResourceTable *table = NULL);
-
-
-
-//----------------------------------------------------------------------
-
-class wxPyTimer {
-public:
-    wxPyTimer(PyObject* notify);
-    ~wxPyTimer();
-    int Interval();
-    void Start(int milliseconds=-1, int oneShot=FALSE);
-    void Stop();
-};
-
-//---------------------------------------------------------------------------
-
-enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
-              wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
-enum wxRelationship { wxUnconstrained = 0,
-                      wxAsIs,
-                      wxPercentOf,
-                      wxAbove,
-                      wxBelow,
-                      wxLeftOf,
-                      wxRightOf,
-                      wxSameAs,
-                      wxAbsolute };
-
-
-class wxIndividualLayoutConstraint {
-public:
-//    wxIndividualLayoutConstraint();
-//    ~wxIndividualLayoutConstraint();
-
-    void Above(wxWindow *otherWin, int margin=0);
-    void Absolute(int value);
-    void AsIs();
-    void Below(wxWindow *otherWin, int margin=0);
-    void Unconstrained();
-    void LeftOf(wxWindow *otherWin, int margin=0);
-    void PercentOf(wxWindow *otherWin, wxEdge edge, int percent);
-    void RightOf(wxWindow *otherWin, int margin=0);
-    void SameAs(wxWindow *otherWin, wxEdge edge, int margin=0);
-    void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value=0, int margin=0);
-};
-
-
-class wxLayoutConstraints {
-public:
-    wxLayoutConstraints();
-
-%readonly
-    wxIndividualLayoutConstraint bottom;
-    wxIndividualLayoutConstraint centreX;
-    wxIndividualLayoutConstraint centreY;
-    wxIndividualLayoutConstraint height;
-    wxIndividualLayoutConstraint left;
-    wxIndividualLayoutConstraint right;
-    wxIndividualLayoutConstraint top;
-    wxIndividualLayoutConstraint width;
-%readwrite
-}
-
-
-//---------------------------------------------------------------------------
-// Regions, etc.
-
-enum wxRegionContain {
-	wxOutRegion, wxPartRegion, wxInRegion
-};
-
-
-class wxRegion {
-public:
-    wxRegion();
-    ~wxRegion();
-
-    void Clear();
-    wxRegionContain Contains(long x, long y);
-    %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
-    %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
-
-    wxRect GetBox();
-    bool Intersect(const wxRect& rect);
-#ifdef __WXMSW__
-    bool IsEmpty();
-#endif
-    bool Subtract(const wxRect& rect);
-    bool Union(const wxRect& rect);
-    bool Xor(const wxRect& rect);
-};
-
-
-
-class wxRegionIterator {
-public:
-    wxRegionIterator(const wxRegion& region);
-    ~wxRegionIterator();
-
-    long GetX();
-    long GetY();
-    long GetW();
-    long GetWidth();
-    long GetH();
-    long GetHeight();
-    wxRect GetRect();
-    bool HaveRects();
-    void Reset();
-
-    %addmethods {
-        void Next() {
-            (*self) ++;
-        }
-    };
-};
-
-
-
-//---------------------------------------------------------------------------
-// Accelerator Entry and Table
-
-class wxAcceleratorEntry {
-public:
-    wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
-    //~wxAcceleratorEntry();  *** ?
-
-    void Set(int flags, int keyCode, int Cmd);
-    int GetFlags();
-    int GetKeyCode();
-    int GetCommand();
-};
-
-
-class wxAcceleratorTable {
-public:
-    // Can also accept a list of 3-tuples
-    wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* LIST);
-    // ~wxAcceleratorEntry(); *** ?
-
-};
-
-//---------------------------------------------------------------------------
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.10  1999/01/30 07:30:14  RD
-// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
-//
-// Various cleanup, tweaks, minor additions, etc. to maintain
-// compatibility with the current wxWindows.
-//
-// Revision 1.9  1998/12/16 22:10:55  RD
-//
-// Tweaks needed to be able to build wxPython with wxGTK.
-//
-// Revision 1.8  1998/12/15 20:41:22  RD
-// Changed the import semantics from "from wxPython import *" to "from
-// wxPython.wx import *"  This is for people who are worried about
-// namespace pollution, they can use "from wxPython import wx" and then
-// prefix all the wxPython identifiers with "wx."
-//
-// Added wxTaskbarIcon for wxMSW.
-//
-// Made the events work for wxGrid.
-//
-// Added wxConfig.
-//
-// Added wxMiniFrame for wxGTK, (untested.)
-//
-// Changed many of the args and return values that were pointers to gdi
-// objects to references to reflect changes in the wxWindows API.
-//
-// Other assorted fixes and additions.
-//
-// Revision 1.7  1998/11/25 08:45:27  RD
-//
-// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
-// Added events for wxGrid
-// Other various fixes and additions
-//
-// Revision 1.6  1998/11/15 23:03:46  RD
-// Removing some ifdef's for wxGTK
-//
-// Revision 1.5  1998/10/20 06:43:59  RD
-// New wxTreeCtrl wrappers (untested)
-// some changes in helpers
-// etc.
-//
-// Revision 1.4  1998/08/18 19:48:19  RD
-// more wxGTK compatibility things.
-//
-// It builds now but there are serious runtime problems...
-//
-// Revision 1.3  1998/08/16 04:31:10  RD
-// More wxGTK work.
-//
-// Revision 1.2  1998/08/15 07:36:41  RD
-// - Moved the header in the .i files out of the code that gets put into
-// the .cpp files.  It caused CVS conflicts because of the RCS ID being
-// different each time.
-//
-// - A few minor fixes.
-//
-// Revision 1.1  1998/08/09 08:25:51  RD
-// Initial version
-//
-//
-
-

utils/wxPython/src/msw/cmndlgs.py

@@ -1,592 +0,0 @@
-# This file was created automatically by SWIG.
-import cmndlgsc
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-import wx
-class wxColourDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxColourData(self.this)
-    def GetChooseFull(self):
-        val = cmndlgsc.wxColourData_GetChooseFull(self.this)
-        return val
-    def GetColour(self):
-        val = cmndlgsc.wxColourData_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetCustomColour(self,arg0):
-        val = cmndlgsc.wxColourData_GetCustomColour(self.this,arg0)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def SetChooseFull(self,arg0):
-        val = cmndlgsc.wxColourData_SetChooseFull(self.this,arg0)
-        return val
-    def SetColour(self,arg0):
-        val = cmndlgsc.wxColourData_SetColour(self.this,arg0.this)
-        return val
-    def SetCustomColour(self,arg0,arg1):
-        val = cmndlgsc.wxColourData_SetCustomColour(self.this,arg0,arg1.this)
-        return val
-    def __repr__(self):
-        return "<C wxColourData instance>"
-class wxColourData(wxColourDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxColourData()
-        self.thisown = 1
-
-
-
-
-class wxColourDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetColourData(self):
-        val = cmndlgsc.wxColourDialog_GetColourData(self.this)
-        val = wxColourDataPtr(val)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxColourDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxColourDialog instance>"
-class wxColourDialog(wxColourDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxColourDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxDirDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPath(self):
-        val = cmndlgsc.wxDirDialog_GetPath(self.this)
-        return val
-    def GetMessage(self):
-        val = cmndlgsc.wxDirDialog_GetMessage(self.this)
-        return val
-    def GetStyle(self):
-        val = cmndlgsc.wxDirDialog_GetStyle(self.this)
-        return val
-    def SetMessage(self,arg0):
-        val = cmndlgsc.wxDirDialog_SetMessage(self.this,arg0)
-        return val
-    def SetPath(self,arg0):
-        val = cmndlgsc.wxDirDialog_SetPath(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxDirDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxDirDialog instance>"
-class wxDirDialog(wxDirDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[3] = argl[3].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxDirDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxFileDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetDirectory(self):
-        val = cmndlgsc.wxFileDialog_GetDirectory(self.this)
-        return val
-    def GetFilename(self):
-        val = cmndlgsc.wxFileDialog_GetFilename(self.this)
-        return val
-    def GetFilterIndex(self):
-        val = cmndlgsc.wxFileDialog_GetFilterIndex(self.this)
-        return val
-    def GetMessage(self):
-        val = cmndlgsc.wxFileDialog_GetMessage(self.this)
-        return val
-    def GetPath(self):
-        val = cmndlgsc.wxFileDialog_GetPath(self.this)
-        return val
-    def GetStyle(self):
-        val = cmndlgsc.wxFileDialog_GetStyle(self.this)
-        return val
-    def GetWildcard(self):
-        val = cmndlgsc.wxFileDialog_GetWildcard(self.this)
-        return val
-    def SetDirectory(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetDirectory(self.this,arg0)
-        return val
-    def SetFilename(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetFilename(self.this,arg0)
-        return val
-    def SetFilterIndex(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetFilterIndex(self.this,arg0)
-        return val
-    def SetMessage(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetMessage(self.this,arg0)
-        return val
-    def SetPath(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetPath(self.this,arg0)
-        return val
-    def SetStyle(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetStyle(self.this,arg0)
-        return val
-    def SetWildcard(self,arg0):
-        val = cmndlgsc.wxFileDialog_SetWildcard(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxFileDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxFileDialog instance>"
-class wxFileDialog(wxFileDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[5] = argl[5].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxFileDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxSingleChoiceDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSelection(self):
-        val = cmndlgsc.wxSingleChoiceDialog_GetSelection(self.this)
-        return val
-    def GetStringSelection(self):
-        val = cmndlgsc.wxSingleChoiceDialog_GetStringSelection(self.this)
-        return val
-    def SetSelection(self,arg0):
-        val = cmndlgsc.wxSingleChoiceDialog_SetSelection(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxSingleChoiceDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxSingleChoiceDialog instance>"
-class wxSingleChoiceDialog(wxSingleChoiceDialogPtr):
-    def __init__(self,arg0,arg1,arg2,arg3,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,(arg0.this,arg1,arg2,arg3,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxTextEntryDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetValue(self):
-        val = cmndlgsc.wxTextEntryDialog_GetValue(self.this)
-        return val
-    def SetValue(self,arg0):
-        val = cmndlgsc.wxTextEntryDialog_SetValue(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxTextEntryDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxTextEntryDialog instance>"
-class wxTextEntryDialog(wxTextEntryDialogPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[3] = argl[3].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxTextEntryDialog,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxFontDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxFontData(self.this)
-    def EnableEffects(self,arg0):
-        val = cmndlgsc.wxFontData_EnableEffects(self.this,arg0)
-        return val
-    def GetAllowSymbols(self):
-        val = cmndlgsc.wxFontData_GetAllowSymbols(self.this)
-        return val
-    def GetColour(self):
-        val = cmndlgsc.wxFontData_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetChosenFont(self):
-        val = cmndlgsc.wxFontData_GetChosenFont(self.this)
-        val = wxFontPtr(val)
-        val.thisown = 1
-        return val
-    def GetEnableEffects(self):
-        val = cmndlgsc.wxFontData_GetEnableEffects(self.this)
-        return val
-    def GetInitialFont(self):
-        val = cmndlgsc.wxFontData_GetInitialFont(self.this)
-        val = wxFontPtr(val)
-        val.thisown = 1
-        return val
-    def GetShowHelp(self):
-        val = cmndlgsc.wxFontData_GetShowHelp(self.this)
-        return val
-    def SetAllowSymbols(self,arg0):
-        val = cmndlgsc.wxFontData_SetAllowSymbols(self.this,arg0)
-        return val
-    def SetChosenFont(self,arg0):
-        val = cmndlgsc.wxFontData_SetChosenFont(self.this,arg0.this)
-        return val
-    def SetColour(self,arg0):
-        val = cmndlgsc.wxFontData_SetColour(self.this,arg0.this)
-        return val
-    def SetInitialFont(self,arg0):
-        val = cmndlgsc.wxFontData_SetInitialFont(self.this,arg0.this)
-        return val
-    def SetRange(self,arg0,arg1):
-        val = cmndlgsc.wxFontData_SetRange(self.this,arg0,arg1)
-        return val
-    def SetShowHelp(self,arg0):
-        val = cmndlgsc.wxFontData_SetShowHelp(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxFontData instance>"
-class wxFontData(wxFontDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxFontData()
-        self.thisown = 1
-
-
-
-
-class wxFontDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetFontData(self):
-        val = cmndlgsc.wxFontDialog_GetFontData(self.this)
-        val = wxFontDataPtr(val)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxFontDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxFontDialog instance>"
-class wxFontDialog(wxFontDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxFontDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxPageSetupDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxPageSetupData(self.this)
-    def EnableHelp(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnableHelp(self.this,arg0)
-        return val
-    def EnableMargins(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnableMargins(self.this,arg0)
-        return val
-    def EnableOrientation(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnableOrientation(self.this,arg0)
-        return val
-    def EnablePaper(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnablePaper(self.this,arg0)
-        return val
-    def EnablePrinter(self,arg0):
-        val = cmndlgsc.wxPageSetupData_EnablePrinter(self.this,arg0)
-        return val
-    def GetPaperSize(self):
-        val = cmndlgsc.wxPageSetupData_GetPaperSize(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMarginTopLeft(self):
-        val = cmndlgsc.wxPageSetupData_GetMarginTopLeft(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMarginBottomRight(self):
-        val = cmndlgsc.wxPageSetupData_GetMarginBottomRight(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMinMarginTopLeft(self):
-        val = cmndlgsc.wxPageSetupData_GetMinMarginTopLeft(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetMinMarginBottomRight(self):
-        val = cmndlgsc.wxPageSetupData_GetMinMarginBottomRight(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetOrientation(self):
-        val = cmndlgsc.wxPageSetupData_GetOrientation(self.this)
-        return val
-    def GetDefaultMinMargins(self):
-        val = cmndlgsc.wxPageSetupData_GetDefaultMinMargins(self.this)
-        return val
-    def GetEnableMargins(self):
-        val = cmndlgsc.wxPageSetupData_GetEnableMargins(self.this)
-        return val
-    def GetEnableOrientation(self):
-        val = cmndlgsc.wxPageSetupData_GetEnableOrientation(self.this)
-        return val
-    def GetEnablePaper(self):
-        val = cmndlgsc.wxPageSetupData_GetEnablePaper(self.this)
-        return val
-    def GetEnablePrinter(self):
-        val = cmndlgsc.wxPageSetupData_GetEnablePrinter(self.this)
-        return val
-    def GetEnableHelp(self):
-        val = cmndlgsc.wxPageSetupData_GetEnableHelp(self.this)
-        return val
-    def GetDefaultInfo(self):
-        val = cmndlgsc.wxPageSetupData_GetDefaultInfo(self.this)
-        return val
-    def SetPaperSize(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetPaperSize(self.this,arg0.this)
-        return val
-    def SetMarginTopLeft(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMarginTopLeft(self.this,arg0.this)
-        return val
-    def SetMarginBottomRight(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMarginBottomRight(self.this,arg0.this)
-        return val
-    def SetMinMarginTopLeft(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMinMarginTopLeft(self.this,arg0.this)
-        return val
-    def SetMinMarginBottomRight(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetMinMarginBottomRight(self.this,arg0.this)
-        return val
-    def SetOrientation(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetOrientation(self.this,arg0)
-        return val
-    def SetDefaultMinMargins(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetDefaultMinMargins(self.this,arg0)
-        return val
-    def SetDefaultInfo(self,arg0):
-        val = cmndlgsc.wxPageSetupData_SetDefaultInfo(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxPageSetupData instance>"
-class wxPageSetupData(wxPageSetupDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxPageSetupData()
-        self.thisown = 1
-
-
-
-
-class wxPageSetupDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPageSetupData(self):
-        val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this)
-        val = wxPageSetupDataPtr(val)
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPageSetupDialog instance>"
-class wxPageSetupDialog(wxPageSetupDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxPageSetupDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxPrintDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            cmndlgsc.delete_wxPrintData(self.this)
-    def EnableHelp(self,arg0):
-        val = cmndlgsc.wxPrintData_EnableHelp(self.this,arg0)
-        return val
-    def EnablePageNumbers(self,arg0):
-        val = cmndlgsc.wxPrintData_EnablePageNumbers(self.this,arg0)
-        return val
-    def EnablePrintToFile(self,arg0):
-        val = cmndlgsc.wxPrintData_EnablePrintToFile(self.this,arg0)
-        return val
-    def EnableSelection(self,arg0):
-        val = cmndlgsc.wxPrintData_EnableSelection(self.this,arg0)
-        return val
-    def GetAllPages(self):
-        val = cmndlgsc.wxPrintData_GetAllPages(self.this)
-        return val
-    def GetCollate(self):
-        val = cmndlgsc.wxPrintData_GetCollate(self.this)
-        return val
-    def GetFromPage(self):
-        val = cmndlgsc.wxPrintData_GetFromPage(self.this)
-        return val
-    def GetMaxPage(self):
-        val = cmndlgsc.wxPrintData_GetMaxPage(self.this)
-        return val
-    def GetMinPage(self):
-        val = cmndlgsc.wxPrintData_GetMinPage(self.this)
-        return val
-    def GetNoCopies(self):
-        val = cmndlgsc.wxPrintData_GetNoCopies(self.this)
-        return val
-    def GetOrientation(self):
-        val = cmndlgsc.wxPrintData_GetOrientation(self.this)
-        return val
-    def GetToPage(self):
-        val = cmndlgsc.wxPrintData_GetToPage(self.this)
-        return val
-    def SetCollate(self,arg0):
-        val = cmndlgsc.wxPrintData_SetCollate(self.this,arg0)
-        return val
-    def SetFromPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetFromPage(self.this,arg0)
-        return val
-    def SetMaxPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetMaxPage(self.this,arg0)
-        return val
-    def SetMinPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetMinPage(self.this,arg0)
-        return val
-    def SetOrientation(self,arg0):
-        val = cmndlgsc.wxPrintData_SetOrientation(self.this,arg0)
-        return val
-    def SetNoCopies(self,arg0):
-        val = cmndlgsc.wxPrintData_SetNoCopies(self.this,arg0)
-        return val
-    def SetPrintToFile(self,arg0):
-        val = cmndlgsc.wxPrintData_SetPrintToFile(self.this,arg0)
-        return val
-    def SetSetupDialog(self,arg0):
-        val = cmndlgsc.wxPrintData_SetSetupDialog(self.this,arg0)
-        return val
-    def SetToPage(self,arg0):
-        val = cmndlgsc.wxPrintData_SetToPage(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxPrintData instance>"
-class wxPrintData(wxPrintDataPtr):
-    def __init__(self) :
-        self.this = cmndlgsc.new_wxPrintData()
-        self.thisown = 1
-
-
-
-
-class wxPrintDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPrintData(self):
-        val = cmndlgsc.wxPrintDialog_GetPrintData(self.this)
-        val = wxPrintDataPtr(val)
-        return val
-    def GetPrintDC(self):
-        val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this)
-        val = wxDCPtr(val)
-        val.thisown = 1
-        return val
-    def ShowModal(self):
-        val = cmndlgsc.wxPrintDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPrintDialog instance>"
-class wxPrintDialog(wxPrintDialogPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxPrintDialog,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxMessageDialogPtr(wxDialogPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ShowModal(self):
-        val = cmndlgsc.wxMessageDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMessageDialog instance>"
-class wxMessageDialog(wxMessageDialogPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(cmndlgsc.new_wxMessageDialog,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/controls.py

@@ -1,839 +0,0 @@
-# This file was created automatically by SWIG.
-import controlsc
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from events import *
-import wx
-class wxControlPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Command(self,arg0):
-        val = controlsc.wxControl_Command(self.this,arg0.this)
-        return val
-    def GetLabel(self):
-        val = controlsc.wxControl_GetLabel(self.this)
-        return val
-    def SetLabel(self,arg0):
-        val = controlsc.wxControl_SetLabel(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxControl instance>"
-class wxControl(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxButtonPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetDefault(self):
-        val = controlsc.wxButton_SetDefault(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxButton instance>"
-class wxButton(wxButtonPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxButton,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxBitmapButtonPtr(wxButtonPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBitmapLabel(self):
-        val = controlsc.wxBitmapButton_GetBitmapLabel(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetBitmapDisabled(self):
-        val = controlsc.wxBitmapButton_GetBitmapDisabled(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetBitmapFocus(self):
-        val = controlsc.wxBitmapButton_GetBitmapFocus(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetBitmapSelected(self):
-        val = controlsc.wxBitmapButton_GetBitmapSelected(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def SetBitmapDisabled(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapDisabled(self.this,arg0.this)
-        return val
-    def SetBitmapFocus(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapFocus(self.this,arg0.this)
-        return val
-    def SetBitmapSelected(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapSelected(self.this,arg0.this)
-        return val
-    def SetBitmapLabel(self,arg0):
-        val = controlsc.wxBitmapButton_SetBitmapLabel(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxBitmapButton instance>"
-class wxBitmapButton(wxBitmapButtonPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxBitmapButton,(arg0.this,arg1,arg2.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxCheckBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetValue(self):
-        val = controlsc.wxCheckBox_GetValue(self.this)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxCheckBox_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxCheckBox instance>"
-class wxCheckBox(wxCheckBoxPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxCheckBox,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxChoicePtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0):
-        val = controlsc.wxChoice_Append(self.this,arg0)
-        return val
-    def Clear(self):
-        val = controlsc.wxChoice_Clear(self.this)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxChoice_FindString(self.this,arg0)
-        return val
-    def GetColumns(self):
-        val = controlsc.wxChoice_GetColumns(self.this)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxChoice_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxChoice_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxChoice_GetStringSelection(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxChoice_Number(self.this)
-        return val
-    def SetColumns(self,*args):
-        val = apply(controlsc.wxChoice_SetColumns,(self.this,)+args)
-        return val
-    def SetSelection(self,arg0):
-        val = controlsc.wxChoice_SetSelection(self.this,arg0)
-        return val
-    def SetStringSelection(self,arg0):
-        val = controlsc.wxChoice_SetStringSelection(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxChoice instance>"
-class wxChoice(wxChoicePtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxChoice,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxComboBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0):
-        val = controlsc.wxComboBox_Append(self.this,arg0)
-        return val
-    def Clear(self):
-        val = controlsc.wxComboBox_Clear(self.this)
-        return val
-    def Copy(self):
-        val = controlsc.wxComboBox_Copy(self.this)
-        return val
-    def Cut(self):
-        val = controlsc.wxComboBox_Cut(self.this)
-        return val
-    def Delete(self,arg0):
-        val = controlsc.wxComboBox_Delete(self.this,arg0)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxComboBox_FindString(self.this,arg0)
-        return val
-    def GetInsertionPoint(self):
-        val = controlsc.wxComboBox_GetInsertionPoint(self.this)
-        return val
-    def GetLastPosition(self):
-        val = controlsc.wxComboBox_GetLastPosition(self.this)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxComboBox_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxComboBox_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxComboBox_GetStringSelection(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxComboBox_GetValue(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxComboBox_Number(self.this)
-        return val
-    def Paste(self):
-        val = controlsc.wxComboBox_Paste(self.this)
-        return val
-    def Replace(self,arg0,arg1,arg2):
-        val = controlsc.wxComboBox_Replace(self.this,arg0,arg1,arg2)
-        return val
-    def Remove(self,arg0,arg1):
-        val = controlsc.wxComboBox_Remove(self.this,arg0,arg1)
-        return val
-    def SetInsertionPoint(self,arg0):
-        val = controlsc.wxComboBox_SetInsertionPoint(self.this,arg0)
-        return val
-    def SetInsertionPointEnd(self):
-        val = controlsc.wxComboBox_SetInsertionPointEnd(self.this)
-        return val
-    def SetSelection(self,arg0,*args):
-        val = apply(controlsc.wxComboBox_SetSelection,(self.this,arg0,)+args)
-        return val
-    def SetMark(self,arg0,arg1):
-        val = controlsc.wxComboBox_SetMark(self.this,arg0,arg1)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxComboBox_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxComboBox instance>"
-class wxComboBox(wxComboBoxPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxComboBox,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxGaugePtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBezelFace(self):
-        val = controlsc.wxGauge_GetBezelFace(self.this)
-        return val
-    def GetRange(self):
-        val = controlsc.wxGauge_GetRange(self.this)
-        return val
-    def GetShadowWidth(self):
-        val = controlsc.wxGauge_GetShadowWidth(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxGauge_GetValue(self.this)
-        return val
-    def SetBezelFace(self,arg0):
-        val = controlsc.wxGauge_SetBezelFace(self.this,arg0)
-        return val
-    def SetRange(self,arg0):
-        val = controlsc.wxGauge_SetRange(self.this,arg0)
-        return val
-    def SetShadowWidth(self,arg0):
-        val = controlsc.wxGauge_SetShadowWidth(self.this,arg0)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxGauge_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxGauge instance>"
-class wxGauge(wxGaugePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxGauge,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxStaticBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxStaticBox instance>"
-class wxStaticBox(wxStaticBoxPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxStaticBox,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-
-
-
-
-class wxStaticTextPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetLabel(self):
-        val = controlsc.wxStaticText_GetLabel(self.this)
-        return val
-    def SetLabel(self,arg0):
-        val = controlsc.wxStaticText_SetLabel(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxStaticText instance>"
-class wxStaticText(wxStaticTextPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxStaticText,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxListBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0):
-        val = controlsc.wxListBox_Append(self.this,arg0)
-        return val
-    def Clear(self):
-        val = controlsc.wxListBox_Clear(self.this)
-        return val
-    def Delete(self,arg0):
-        val = controlsc.wxListBox_Delete(self.this,arg0)
-        return val
-    def Deselect(self,arg0):
-        val = controlsc.wxListBox_Deselect(self.this,arg0)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxListBox_FindString(self.this,arg0)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxListBox_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxListBox_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxListBox_GetStringSelection(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxListBox_Number(self.this)
-        return val
-    def Selected(self,arg0):
-        val = controlsc.wxListBox_Selected(self.this,arg0)
-        return val
-    def Set(self,arg0,*args):
-        val = apply(controlsc.wxListBox_Set,(self.this,arg0,)+args)
-        return val
-    def SetFirstItem(self,arg0):
-        val = controlsc.wxListBox_SetFirstItem(self.this,arg0)
-        return val
-    def SetFirstItemStr(self,arg0):
-        val = controlsc.wxListBox_SetFirstItemStr(self.this,arg0)
-        return val
-    def SetSelection(self,arg0,*args):
-        val = apply(controlsc.wxListBox_SetSelection,(self.this,arg0,)+args)
-        return val
-    def SetString(self,arg0,arg1):
-        val = controlsc.wxListBox_SetString(self.this,arg0,arg1)
-        return val
-    def SetStringSelection(self,arg0,*args):
-        val = apply(controlsc.wxListBox_SetStringSelection,(self.this,arg0,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxListBox instance>"
-class wxListBox(wxListBoxPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxListBox,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxCheckListBoxPtr(wxListBoxPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def IsChecked(self,arg0):
-        val = controlsc.wxCheckListBox_IsChecked(self.this,arg0)
-        return val
-    def Check(self,arg0,*args):
-        val = apply(controlsc.wxCheckListBox_Check,(self.this,arg0,)+args)
-        return val
-    def GetItemHeight(self):
-        val = controlsc.wxCheckListBox_GetItemHeight(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCheckListBox instance>"
-class wxCheckListBox(wxCheckListBoxPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxCheckListBox,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxTextCtrlPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Clear(self):
-        val = controlsc.wxTextCtrl_Clear(self.this)
-        return val
-    def Copy(self):
-        val = controlsc.wxTextCtrl_Copy(self.this)
-        return val
-    def Cut(self):
-        val = controlsc.wxTextCtrl_Cut(self.this)
-        return val
-    def DiscardEdits(self):
-        val = controlsc.wxTextCtrl_DiscardEdits(self.this)
-        return val
-    def GetInsertionPoint(self):
-        val = controlsc.wxTextCtrl_GetInsertionPoint(self.this)
-        return val
-    def GetLastPosition(self):
-        val = controlsc.wxTextCtrl_GetLastPosition(self.this)
-        return val
-    def GetLineLength(self,arg0):
-        val = controlsc.wxTextCtrl_GetLineLength(self.this,arg0)
-        return val
-    def GetLineText(self,arg0):
-        val = controlsc.wxTextCtrl_GetLineText(self.this,arg0)
-        return val
-    def GetNumberOfLines(self):
-        val = controlsc.wxTextCtrl_GetNumberOfLines(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxTextCtrl_GetValue(self.this)
-        return val
-    def IsModified(self):
-        val = controlsc.wxTextCtrl_IsModified(self.this)
-        return val
-    def LoadFile(self,arg0):
-        val = controlsc.wxTextCtrl_LoadFile(self.this,arg0)
-        return val
-    def Paste(self):
-        val = controlsc.wxTextCtrl_Paste(self.this)
-        return val
-    def PositionToXY(self,arg0):
-        val = controlsc.wxTextCtrl_PositionToXY(self.this,arg0)
-        return val
-    def Remove(self,arg0,arg1):
-        val = controlsc.wxTextCtrl_Remove(self.this,arg0,arg1)
-        return val
-    def Replace(self,arg0,arg1,arg2):
-        val = controlsc.wxTextCtrl_Replace(self.this,arg0,arg1,arg2)
-        return val
-    def SaveFile(self,arg0):
-        val = controlsc.wxTextCtrl_SaveFile(self.this,arg0)
-        return val
-    def SetEditable(self,arg0):
-        val = controlsc.wxTextCtrl_SetEditable(self.this,arg0)
-        return val
-    def SetInsertionPoint(self,arg0):
-        val = controlsc.wxTextCtrl_SetInsertionPoint(self.this,arg0)
-        return val
-    def SetInsertionPointEnd(self):
-        val = controlsc.wxTextCtrl_SetInsertionPointEnd(self.this)
-        return val
-    def SetSelection(self,arg0,arg1):
-        val = controlsc.wxTextCtrl_SetSelection(self.this,arg0,arg1)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxTextCtrl_SetValue(self.this,arg0)
-        return val
-    def ShowPosition(self,arg0):
-        val = controlsc.wxTextCtrl_ShowPosition(self.this,arg0)
-        return val
-    def WriteText(self,arg0):
-        val = controlsc.wxTextCtrl_WriteText(self.this,arg0)
-        return val
-    def XYToPosition(self,arg0,arg1):
-        val = controlsc.wxTextCtrl_XYToPosition(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxTextCtrl instance>"
-class wxTextCtrl(wxTextCtrlPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxTextCtrl,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxScrollBarPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetRange(self):
-        val = controlsc.wxScrollBar_GetRange(self.this)
-        return val
-    def GetPageSize(self):
-        val = controlsc.wxScrollBar_GetPageSize(self.this)
-        return val
-    def GetThumbPosition(self):
-        val = controlsc.wxScrollBar_GetThumbPosition(self.this)
-        return val
-    def GetThumbSize(self):
-        val = controlsc.wxScrollBar_GetThumbSize(self.this)
-        return val
-    def SetThumbPosition(self,arg0):
-        val = controlsc.wxScrollBar_SetThumbPosition(self.this,arg0)
-        return val
-    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(controlsc.wxScrollBar_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxScrollBar instance>"
-class wxScrollBar(wxScrollBarPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxScrollBar,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxSpinButtonPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetMax(self):
-        val = controlsc.wxSpinButton_GetMax(self.this)
-        return val
-    def GetMin(self):
-        val = controlsc.wxSpinButton_GetMin(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxSpinButton_GetValue(self.this)
-        return val
-    def SetRange(self,arg0,arg1):
-        val = controlsc.wxSpinButton_SetRange(self.this,arg0,arg1)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxSpinButton_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxSpinButton instance>"
-class wxSpinButton(wxSpinButtonPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxSpinButton,(arg0.this,)+args)
-        self.thisown = 1
-
-
-
-
-class wxStaticBitmapPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBitmap(self):
-        val = controlsc.wxStaticBitmap_GetBitmap(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def SetBitmap(self,arg0):
-        val = controlsc.wxStaticBitmap_SetBitmap(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxStaticBitmap instance>"
-class wxStaticBitmap(wxStaticBitmapPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxStaticBitmap,(arg0.this,arg1,arg2.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxRadioBoxPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def EnableBox(self,arg0):
-        val = controlsc.wxRadioBox_EnableBox(self.this,arg0)
-        return val
-    def Enable(self,arg0,arg1):
-        val = controlsc.wxRadioBox_Enable(self.this,arg0,arg1)
-        return val
-    def FindString(self,arg0):
-        val = controlsc.wxRadioBox_FindString(self.this,arg0)
-        return val
-    def GetBoxLabel(self):
-        val = controlsc.wxRadioBox_GetBoxLabel(self.this)
-        return val
-    def GetLabel(self,arg0):
-        val = controlsc.wxRadioBox_GetLabel(self.this,arg0)
-        return val
-    def GetSelection(self):
-        val = controlsc.wxRadioBox_GetSelection(self.this)
-        return val
-    def GetString(self,arg0):
-        val = controlsc.wxRadioBox_GetString(self.this,arg0)
-        return val
-    def GetStringSelection(self):
-        val = controlsc.wxRadioBox_GetStringSelection(self.this)
-        return val
-    def Number(self):
-        val = controlsc.wxRadioBox_Number(self.this)
-        return val
-    def SetBoxLabel(self,arg0):
-        val = controlsc.wxRadioBox_SetBoxLabel(self.this,arg0)
-        return val
-    def SetLabel(self,arg0,arg1):
-        val = controlsc.wxRadioBox_SetLabel(self.this,arg0,arg1)
-        return val
-    def SetSelection(self,arg0):
-        val = controlsc.wxRadioBox_SetSelection(self.this,arg0)
-        return val
-    def SetStringSelection(self,arg0):
-        val = controlsc.wxRadioBox_SetStringSelection(self.this,arg0)
-        return val
-    def Show(self,arg0):
-        val = controlsc.wxRadioBox_Show(self.this,arg0)
-        return val
-    def ShowItem(self,arg0,arg1):
-        val = controlsc.wxRadioBox_ShowItem(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxRadioBox instance>"
-class wxRadioBox(wxRadioBoxPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxRadioBox,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxRadioButtonPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetValue(self):
-        val = controlsc.wxRadioButton_GetValue(self.this)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxRadioButton_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxRadioButton instance>"
-class wxRadioButton(wxRadioButtonPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxRadioButton,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxSliderPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ClearSel(self):
-        val = controlsc.wxSlider_ClearSel(self.this)
-        return val
-    def ClearTicks(self):
-        val = controlsc.wxSlider_ClearTicks(self.this)
-        return val
-    def GetLineSize(self):
-        val = controlsc.wxSlider_GetLineSize(self.this)
-        return val
-    def GetMax(self):
-        val = controlsc.wxSlider_GetMax(self.this)
-        return val
-    def GetMin(self):
-        val = controlsc.wxSlider_GetMin(self.this)
-        return val
-    def GetPageSize(self):
-        val = controlsc.wxSlider_GetPageSize(self.this)
-        return val
-    def GetSelEnd(self):
-        val = controlsc.wxSlider_GetSelEnd(self.this)
-        return val
-    def GetSelStart(self):
-        val = controlsc.wxSlider_GetSelStart(self.this)
-        return val
-    def GetThumbLength(self):
-        val = controlsc.wxSlider_GetThumbLength(self.this)
-        return val
-    def GetTickFreq(self):
-        val = controlsc.wxSlider_GetTickFreq(self.this)
-        return val
-    def GetValue(self):
-        val = controlsc.wxSlider_GetValue(self.this)
-        return val
-    def SetRange(self,arg0,arg1):
-        val = controlsc.wxSlider_SetRange(self.this,arg0,arg1)
-        return val
-    def SetTickFreq(self,arg0,arg1):
-        val = controlsc.wxSlider_SetTickFreq(self.this,arg0,arg1)
-        return val
-    def SetLineSize(self,arg0):
-        val = controlsc.wxSlider_SetLineSize(self.this,arg0)
-        return val
-    def SetPageSize(self,arg0):
-        val = controlsc.wxSlider_SetPageSize(self.this,arg0)
-        return val
-    def SetSelection(self,arg0,arg1):
-        val = controlsc.wxSlider_SetSelection(self.this,arg0,arg1)
-        return val
-    def SetThumbLength(self,arg0):
-        val = controlsc.wxSlider_SetThumbLength(self.this,arg0)
-        return val
-    def SetTick(self,arg0):
-        val = controlsc.wxSlider_SetTick(self.this,arg0)
-        return val
-    def SetValue(self,arg0):
-        val = controlsc.wxSlider_SetValue(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxSlider instance>"
-class wxSlider(wxSliderPtr):
-    def __init__(self,arg0,arg1,arg2,arg3,arg4,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controlsc.new_wxSlider,(arg0.this,arg1,arg2,arg3,arg4,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/controls2.py

@@ -1,625 +0,0 @@
-# This file was created automatically by SWIG.
-import controls2c
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from events import *
-
-from controls import *
-import wx
-class wxListItemPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            controls2c.delete_wxListItem(self.this)
-    def __setattr__(self,name,value):
-        if name == "m_mask" :
-            controls2c.wxListItem_m_mask_set(self.this,value)
-            return
-        if name == "m_itemId" :
-            controls2c.wxListItem_m_itemId_set(self.this,value)
-            return
-        if name == "m_col" :
-            controls2c.wxListItem_m_col_set(self.this,value)
-            return
-        if name == "m_state" :
-            controls2c.wxListItem_m_state_set(self.this,value)
-            return
-        if name == "m_stateMask" :
-            controls2c.wxListItem_m_stateMask_set(self.this,value)
-            return
-        if name == "m_text" :
-            controls2c.wxListItem_m_text_set(self.this,value)
-            return
-        if name == "m_image" :
-            controls2c.wxListItem_m_image_set(self.this,value)
-            return
-        if name == "m_data" :
-            controls2c.wxListItem_m_data_set(self.this,value)
-            return
-        if name == "m_format" :
-            controls2c.wxListItem_m_format_set(self.this,value)
-            return
-        if name == "m_width" :
-            controls2c.wxListItem_m_width_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_mask" : 
-            return controls2c.wxListItem_m_mask_get(self.this)
-        if name == "m_itemId" : 
-            return controls2c.wxListItem_m_itemId_get(self.this)
-        if name == "m_col" : 
-            return controls2c.wxListItem_m_col_get(self.this)
-        if name == "m_state" : 
-            return controls2c.wxListItem_m_state_get(self.this)
-        if name == "m_stateMask" : 
-            return controls2c.wxListItem_m_stateMask_get(self.this)
-        if name == "m_text" : 
-            return controls2c.wxListItem_m_text_get(self.this)
-        if name == "m_image" : 
-            return controls2c.wxListItem_m_image_get(self.this)
-        if name == "m_data" : 
-            return controls2c.wxListItem_m_data_get(self.this)
-        if name == "m_format" : 
-            return controls2c.wxListItem_m_format_get(self.this)
-        if name == "m_width" : 
-            return controls2c.wxListItem_m_width_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxListItem instance>"
-class wxListItem(wxListItemPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxListItem()
-        self.thisown = 1
-
-
-
-
-class wxListEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __setattr__(self,name,value):
-        if name == "m_code" :
-            controls2c.wxListEvent_m_code_set(self.this,value)
-            return
-        if name == "m_itemIndex" :
-            controls2c.wxListEvent_m_itemIndex_set(self.this,value)
-            return
-        if name == "m_oldItemIndex" :
-            controls2c.wxListEvent_m_oldItemIndex_set(self.this,value)
-            return
-        if name == "m_col" :
-            controls2c.wxListEvent_m_col_set(self.this,value)
-            return
-        if name == "m_cancelled" :
-            controls2c.wxListEvent_m_cancelled_set(self.this,value)
-            return
-        if name == "m_pointDrag" :
-            controls2c.wxListEvent_m_pointDrag_set(self.this,value.this)
-            return
-        if name == "m_item" :
-            controls2c.wxListEvent_m_item_set(self.this,value.this)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_code" : 
-            return controls2c.wxListEvent_m_code_get(self.this)
-        if name == "m_itemIndex" : 
-            return controls2c.wxListEvent_m_itemIndex_get(self.this)
-        if name == "m_oldItemIndex" : 
-            return controls2c.wxListEvent_m_oldItemIndex_get(self.this)
-        if name == "m_col" : 
-            return controls2c.wxListEvent_m_col_get(self.this)
-        if name == "m_cancelled" : 
-            return controls2c.wxListEvent_m_cancelled_get(self.this)
-        if name == "m_pointDrag" : 
-            return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self.this))
-        if name == "m_item" : 
-            return wxListItemPtr(controls2c.wxListEvent_m_item_get(self.this))
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxListEvent instance>"
-class wxListEvent(wxListEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxListCtrlPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Arrange(self,*args):
-        val = apply(controls2c.wxListCtrl_Arrange,(self.this,)+args)
-        return val
-    def DeleteItem(self,arg0):
-        val = controls2c.wxListCtrl_DeleteItem(self.this,arg0)
-        return val
-    def DeleteAllItems(self):
-        val = controls2c.wxListCtrl_DeleteAllItems(self.this)
-        return val
-    def DeleteColumn(self,arg0):
-        val = controls2c.wxListCtrl_DeleteColumn(self.this,arg0)
-        return val
-    def DeleteAllColumns(self):
-        val = controls2c.wxListCtrl_DeleteAllColumns(self.this)
-        return val
-    def ClearAll(self):
-        val = controls2c.wxListCtrl_ClearAll(self.this)
-        return val
-    def EditLabel(self,arg0):
-        val = controls2c.wxListCtrl_EditLabel(self.this,arg0)
-        val = wxTextCtrlPtr(val)
-        return val
-    def EndEditLabel(self,arg0):
-        val = controls2c.wxListCtrl_EndEditLabel(self.this,arg0)
-        return val
-    def GetEditControl(self):
-        val = controls2c.wxListCtrl_GetEditControl(self.this)
-        val = wxTextCtrlPtr(val)
-        return val
-    def EnsureVisible(self,arg0):
-        val = controls2c.wxListCtrl_EnsureVisible(self.this,arg0)
-        return val
-    def FindItem(self,arg0,arg1,*args):
-        val = apply(controls2c.wxListCtrl_FindItem,(self.this,arg0,arg1,)+args)
-        return val
-    def FindItemData(self,arg0,arg1):
-        val = controls2c.wxListCtrl_FindItemData(self.this,arg0,arg1)
-        return val
-    def FindItemAtPos(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_FindItemAtPos(self.this,arg0,arg1.this,arg2)
-        return val
-    def GetColumn(self,arg0,arg1):
-        val = controls2c.wxListCtrl_GetColumn(self.this,arg0,arg1.this)
-        return val
-    def GetColumnWidth(self,arg0):
-        val = controls2c.wxListCtrl_GetColumnWidth(self.this,arg0)
-        return val
-    def GetCountPerPage(self):
-        val = controls2c.wxListCtrl_GetCountPerPage(self.this)
-        return val
-    def GetImageList(self,arg0):
-        val = controls2c.wxListCtrl_GetImageList(self.this,arg0)
-        return val
-    def GetItemData(self,arg0):
-        val = controls2c.wxListCtrl_GetItemData(self.this,arg0)
-        return val
-    def GetItem(self):
-        val = controls2c.wxListCtrl_GetItem(self.this)
-        val = wxListItemPtr(val)
-        val.thisown = 1
-        return val
-    def GetItemPosition(self,arg0):
-        val = controls2c.wxListCtrl_GetItemPosition(self.this,arg0)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetItemRect(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_GetItemRect,(self.this,arg0,)+args)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def GetItemState(self,arg0,arg1):
-        val = controls2c.wxListCtrl_GetItemState(self.this,arg0,arg1)
-        return val
-    def GetItemCount(self):
-        val = controls2c.wxListCtrl_GetItemCount(self.this)
-        return val
-    def GetItemSpacing(self,arg0):
-        val = controls2c.wxListCtrl_GetItemSpacing(self.this,arg0)
-        return val
-    def GetItemText(self,arg0):
-        val = controls2c.wxListCtrl_GetItemText(self.this,arg0)
-        return val
-    def GetNextItem(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_GetNextItem,(self.this,arg0,)+args)
-        return val
-    def GetSelectedItemCount(self):
-        val = controls2c.wxListCtrl_GetSelectedItemCount(self.this)
-        return val
-    def GetTextColour(self):
-        val = controls2c.wxListCtrl_GetTextColour(self.this)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def SetTextColour(self,arg0):
-        val = controls2c.wxListCtrl_SetTextColour(self.this,arg0.this)
-        return val
-    def GetTopItem(self):
-        val = controls2c.wxListCtrl_GetTopItem(self.this)
-        return val
-    def HitTest(self,arg0):
-        val = controls2c.wxListCtrl_HitTest(self.this,arg0.this)
-        return val
-    def InsertColumnWithInfo(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertColumnWithInfo(self.this,arg0,arg1.this)
-        return val
-    def InsertColumn(self,arg0,arg1,*args):
-        val = apply(controls2c.wxListCtrl_InsertColumn,(self.this,arg0,arg1,)+args)
-        return val
-    def InsertItem(self,arg0):
-        val = controls2c.wxListCtrl_InsertItem(self.this,arg0.this)
-        return val
-    def InsertStringItem(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertStringItem(self.this,arg0,arg1)
-        return val
-    def InsertImageItem(self,arg0,arg1):
-        val = controls2c.wxListCtrl_InsertImageItem(self.this,arg0,arg1)
-        return val
-    def InsertImageStringItem(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_InsertImageStringItem(self.this,arg0,arg1,arg2)
-        return val
-    def ScrollList(self,arg0,arg1):
-        val = controls2c.wxListCtrl_ScrollList(self.this,arg0,arg1)
-        return val
-    def SetBackgroundColour(self,arg0):
-        val = controls2c.wxListCtrl_SetBackgroundColour(self.this,arg0.this)
-        return val
-    def SetColumn(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetColumn(self.this,arg0,arg1.this)
-        return val
-    def SetColumnWidth(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetColumnWidth(self.this,arg0,arg1)
-        return val
-    def SetImageList(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetImageList(self.this,arg0,arg1)
-        return val
-    def SetItem(self,arg0):
-        val = controls2c.wxListCtrl_SetItem(self.this,arg0.this)
-        return val
-    def SetItemString(self,arg0,arg1,arg2,*args):
-        val = apply(controls2c.wxListCtrl_SetItemString,(self.this,arg0,arg1,arg2,)+args)
-        return val
-    def SetItemData(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemData(self.this,arg0,arg1)
-        return val
-    def SetItemImage(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_SetItemImage(self.this,arg0,arg1,arg2)
-        return val
-    def SetItemPosition(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemPosition(self.this,arg0,arg1.this)
-        return val
-    def SetItemState(self,arg0,arg1,arg2):
-        val = controls2c.wxListCtrl_SetItemState(self.this,arg0,arg1,arg2)
-        return val
-    def SetItemText(self,arg0,arg1):
-        val = controls2c.wxListCtrl_SetItemText(self.this,arg0,arg1)
-        return val
-    def SetSingleStyle(self,arg0,*args):
-        val = apply(controls2c.wxListCtrl_SetSingleStyle,(self.this,arg0,)+args)
-        return val
-    def SetWindowStyleFlag(self,arg0):
-        val = controls2c.wxListCtrl_SetWindowStyleFlag(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxListCtrl instance>"
-class wxListCtrl(wxListCtrlPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controls2c.new_wxListCtrl,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxTreeItemIdPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            controls2c.delete_wxTreeItemId(self.this)
-    def IsOk(self):
-        val = controls2c.wxTreeItemId_IsOk(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxTreeItemId instance>"
-class wxTreeItemId(wxTreeItemIdPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxTreeItemId()
-        self.thisown = 1
-
-
-
-
-class wxTreeItemDataPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            controls2c.delete_wxTreeItemData(self.this)
-    def GetId(self):
-        val = controls2c.wxTreeItemData_GetId(self.this)
-        val = wxTreeItemIdPtr(val)
-        return val
-    def SetId(self,arg0):
-        val = controls2c.wxTreeItemData_SetId(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxTreeItemData instance>"
-class wxTreeItemData(wxTreeItemDataPtr):
-    def __init__(self) :
-        self.this = controls2c.new_wxTreeItemData()
-        self.thisown = 1
-
-
-
-
-class wxTreeEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetItem(self):
-        val = controls2c.wxTreeEvent_GetItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetOldItem(self):
-        val = controls2c.wxTreeEvent_GetOldItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetPoint(self):
-        val = controls2c.wxTreeEvent_GetPoint(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetCode(self):
-        val = controls2c.wxTreeEvent_GetCode(self.this)
-        return val
-    def Veto(self):
-        val = controls2c.wxTreeEvent_Veto(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxTreeEvent instance>"
-class wxTreeEvent(wxTreeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxTreeCtrlPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetCount(self):
-        val = controls2c.wxTreeCtrl_GetCount(self.this)
-        return val
-    def GetIndent(self):
-        val = controls2c.wxTreeCtrl_GetIndent(self.this)
-        return val
-    def SetIndent(self,arg0):
-        val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
-        return val
-    def GetImageList(self):
-        val = controls2c.wxTreeCtrl_GetImageList(self.this)
-        return val
-    def GetStateImageList(self):
-        val = controls2c.wxTreeCtrl_GetStateImageList(self.this)
-        return val
-    def SetImageList(self,arg0):
-        val = controls2c.wxTreeCtrl_SetImageList(self.this,arg0)
-        return val
-    def SetStateImageList(self,arg0):
-        val = controls2c.wxTreeCtrl_SetStateImageList(self.this,arg0)
-        return val
-    def GetItemText(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0.this)
-        return val
-    def GetItemImage(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemImage(self.this,arg0.this)
-        return val
-    def GetItemSelectedImage(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this)
-        return val
-    def GetItemData(self,arg0):
-        val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this)
-        val = wxTreeItemDataPtr(val)
-        return val
-    def SetItemText(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1)
-        return val
-    def SetItemImage(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0.this,arg1)
-        return val
-    def SetItemSelectedImage(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1)
-        return val
-    def SetItemData(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this)
-        return val
-    def SetItemHasChildren(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args)
-        return val
-    def IsVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this)
-        return val
-    def ItemHasChildren(self,arg0):
-        val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0.this)
-        return val
-    def IsExpanded(self,arg0):
-        val = controls2c.wxTreeCtrl_IsExpanded(self.this,arg0.this)
-        return val
-    def IsSelected(self,arg0):
-        val = controls2c.wxTreeCtrl_IsSelected(self.this,arg0.this)
-        return val
-    def GetRootItem(self):
-        val = controls2c.wxTreeCtrl_GetRootItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetSelection(self):
-        val = controls2c.wxTreeCtrl_GetSelection(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetParent(self,arg0):
-        val = controls2c.wxTreeCtrl_GetParent(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetFirstChild(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
-        return val
-    def GetNextChild(self,arg0,arg1):
-        val = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
-        return val
-    def GetNextSibling(self,arg0):
-        val = controls2c.wxTreeCtrl_GetNextSibling(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetPrevSibling(self,arg0):
-        val = controls2c.wxTreeCtrl_GetPrevSibling(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetFirstVisibleItem(self):
-        val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetNextVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_GetNextVisible(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def GetPrevVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_GetPrevVisible(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def AddRoot(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_AddRoot,(self.this,arg0,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def PrependItem(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_PrependItem,(self.this,arg0.this,arg1,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def InsertItem(self,arg0,arg1,arg2,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0.this,arg1.this,arg2,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def AppendItem(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        val = apply(controls2c.wxTreeCtrl_AppendItem,(self.this,arg0.this,arg1,)+args)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def Delete(self,arg0):
-        val = controls2c.wxTreeCtrl_Delete(self.this,arg0.this)
-        return val
-    def DeleteChildren(self,arg0):
-        val = controls2c.wxTreeCtrl_DeleteChildren(self.this,arg0.this)
-        return val
-    def DeleteAllItems(self):
-        val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
-        return val
-    def Expand(self,arg0):
-        val = controls2c.wxTreeCtrl_Expand(self.this,arg0.this)
-        return val
-    def Collapse(self,arg0):
-        val = controls2c.wxTreeCtrl_Collapse(self.this,arg0.this)
-        return val
-    def CollapseAndReset(self,arg0):
-        val = controls2c.wxTreeCtrl_CollapseAndReset(self.this,arg0.this)
-        return val
-    def Toggle(self,arg0):
-        val = controls2c.wxTreeCtrl_Toggle(self.this,arg0.this)
-        return val
-    def Unselect(self):
-        val = controls2c.wxTreeCtrl_Unselect(self.this)
-        return val
-    def SelectItem(self,arg0):
-        val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0.this)
-        return val
-    def EnsureVisible(self,arg0):
-        val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0.this)
-        return val
-    def ScrollTo(self,arg0):
-        val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0.this)
-        return val
-    def EditLabel(self,arg0):
-        val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0.this)
-        val = wxTextCtrlPtr(val)
-        return val
-    def GetEditControl(self):
-        val = controls2c.wxTreeCtrl_GetEditControl(self.this)
-        val = wxTextCtrlPtr(val)
-        return val
-    def EndEditLabel(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_EndEditLabel,(self.this,arg0.this,)+args)
-        return val
-    def SetItemBold(self,arg0,*args):
-        val = apply(controls2c.wxTreeCtrl_SetItemBold,(self.this,arg0.this,)+args)
-        return val
-    def IsBold(self,arg0):
-        val = controls2c.wxTreeCtrl_IsBold(self.this,arg0.this)
-        return val
-    def HitTest(self,arg0):
-        val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
-        val = wxTreeItemIdPtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxTreeCtrl instance>"
-class wxTreeCtrl(wxTreeCtrlPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(controls2c.new_wxTreeCtrl,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/events.py

@@ -1,630 +0,0 @@
-# This file was created automatically by SWIG.
-import eventsc
-
-from misc import *
-class wxEventPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetEventObject(self):
-        val = eventsc.wxEvent_GetEventObject(self.this)
-        return val
-    def GetEventType(self):
-        val = eventsc.wxEvent_GetEventType(self.this)
-        return val
-    def GetId(self):
-        val = eventsc.wxEvent_GetId(self.this)
-        return val
-    def GetSkipped(self):
-        val = eventsc.wxEvent_GetSkipped(self.this)
-        return val
-    def GetTimestamp(self):
-        val = eventsc.wxEvent_GetTimestamp(self.this)
-        return val
-    def SetEventObject(self,arg0):
-        val = eventsc.wxEvent_SetEventObject(self.this,arg0)
-        return val
-    def SetEventType(self,arg0):
-        val = eventsc.wxEvent_SetEventType(self.this,arg0)
-        return val
-    def SetId(self,arg0):
-        val = eventsc.wxEvent_SetId(self.this,arg0)
-        return val
-    def SetTimestamp(self,arg0):
-        val = eventsc.wxEvent_SetTimestamp(self.this,arg0)
-        return val
-    def Skip(self,*args):
-        val = apply(eventsc.wxEvent_Skip,(self.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxEvent instance>"
-class wxEvent(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSizeEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSize(self):
-        val = eventsc.wxSizeEvent_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxSizeEvent instance>"
-class wxSizeEvent(wxSizeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxCloseEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def CanVeto(self):
-        val = eventsc.wxCloseEvent_CanVeto(self.this)
-        return val
-    def GetLoggingOff(self):
-        val = eventsc.wxCloseEvent_GetLoggingOff(self.this)
-        return val
-    def Veto(self,*args):
-        val = apply(eventsc.wxCloseEvent_Veto,(self.this,)+args)
-        return val
-    def GetVeto(self):
-        val = eventsc.wxCloseEvent_GetVeto(self.this)
-        return val
-    def SetForce(self,arg0):
-        val = eventsc.wxCloseEvent_SetForce(self.this,arg0)
-        return val
-    def SetCanVeto(self,arg0):
-        val = eventsc.wxCloseEvent_SetCanVeto(self.this,arg0)
-        return val
-    def SetLoggingOff(self,arg0):
-        val = eventsc.wxCloseEvent_SetLoggingOff(self.this,arg0)
-        return val
-    def GetForce(self):
-        val = eventsc.wxCloseEvent_GetForce(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCloseEvent instance>"
-class wxCloseEvent(wxCloseEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxCommandEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Checked(self):
-        val = eventsc.wxCommandEvent_Checked(self.this)
-        return val
-    def GetExtraLong(self):
-        val = eventsc.wxCommandEvent_GetExtraLong(self.this)
-        return val
-    def GetInt(self):
-        val = eventsc.wxCommandEvent_GetInt(self.this)
-        return val
-    def GetSelection(self):
-        val = eventsc.wxCommandEvent_GetSelection(self.this)
-        return val
-    def GetString(self):
-        val = eventsc.wxCommandEvent_GetString(self.this)
-        return val
-    def IsSelection(self):
-        val = eventsc.wxCommandEvent_IsSelection(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCommandEvent instance>"
-class wxCommandEvent(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxScrollEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetOrientation(self):
-        val = eventsc.wxScrollEvent_GetOrientation(self.this)
-        return val
-    def GetPosition(self):
-        val = eventsc.wxScrollEvent_GetPosition(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxScrollEvent instance>"
-class wxScrollEvent(wxScrollEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSpinEventPtr(wxScrollEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxSpinEvent instance>"
-class wxSpinEvent(wxSpinEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMouseEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def IsButton(self):
-        val = eventsc.wxMouseEvent_IsButton(self.this)
-        return val
-    def ButtonDown(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonDown,(self.this,)+args)
-        return val
-    def ButtonDClick(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonDClick,(self.this,)+args)
-        return val
-    def ButtonUp(self,*args):
-        val = apply(eventsc.wxMouseEvent_ButtonUp,(self.this,)+args)
-        return val
-    def Button(self,arg0):
-        val = eventsc.wxMouseEvent_Button(self.this,arg0)
-        return val
-    def ButtonIsDown(self,arg0):
-        val = eventsc.wxMouseEvent_ButtonIsDown(self.this,arg0)
-        return val
-    def ControlDown(self):
-        val = eventsc.wxMouseEvent_ControlDown(self.this)
-        return val
-    def MetaDown(self):
-        val = eventsc.wxMouseEvent_MetaDown(self.this)
-        return val
-    def AltDown(self):
-        val = eventsc.wxMouseEvent_AltDown(self.this)
-        return val
-    def ShiftDown(self):
-        val = eventsc.wxMouseEvent_ShiftDown(self.this)
-        return val
-    def LeftDown(self):
-        val = eventsc.wxMouseEvent_LeftDown(self.this)
-        return val
-    def MiddleDown(self):
-        val = eventsc.wxMouseEvent_MiddleDown(self.this)
-        return val
-    def RightDown(self):
-        val = eventsc.wxMouseEvent_RightDown(self.this)
-        return val
-    def LeftUp(self):
-        val = eventsc.wxMouseEvent_LeftUp(self.this)
-        return val
-    def MiddleUp(self):
-        val = eventsc.wxMouseEvent_MiddleUp(self.this)
-        return val
-    def RightUp(self):
-        val = eventsc.wxMouseEvent_RightUp(self.this)
-        return val
-    def LeftDClick(self):
-        val = eventsc.wxMouseEvent_LeftDClick(self.this)
-        return val
-    def MiddleDClick(self):
-        val = eventsc.wxMouseEvent_MiddleDClick(self.this)
-        return val
-    def RightDClick(self):
-        val = eventsc.wxMouseEvent_RightDClick(self.this)
-        return val
-    def LeftIsDown(self):
-        val = eventsc.wxMouseEvent_LeftIsDown(self.this)
-        return val
-    def MiddleIsDown(self):
-        val = eventsc.wxMouseEvent_MiddleIsDown(self.this)
-        return val
-    def RightIsDown(self):
-        val = eventsc.wxMouseEvent_RightIsDown(self.this)
-        return val
-    def Dragging(self):
-        val = eventsc.wxMouseEvent_Dragging(self.this)
-        return val
-    def Moving(self):
-        val = eventsc.wxMouseEvent_Moving(self.this)
-        return val
-    def Entering(self):
-        val = eventsc.wxMouseEvent_Entering(self.this)
-        return val
-    def Leaving(self):
-        val = eventsc.wxMouseEvent_Leaving(self.this)
-        return val
-    def Position(self):
-        val = eventsc.wxMouseEvent_Position(self.this)
-        return val
-    def GetPosition(self):
-        val = eventsc.wxMouseEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetLogicalPosition(self,arg0):
-        val = eventsc.wxMouseEvent_GetLogicalPosition(self.this,arg0.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetX(self):
-        val = eventsc.wxMouseEvent_GetX(self.this)
-        return val
-    def GetY(self):
-        val = eventsc.wxMouseEvent_GetY(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMouseEvent instance>"
-class wxMouseEvent(wxMouseEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxKeyEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ControlDown(self):
-        val = eventsc.wxKeyEvent_ControlDown(self.this)
-        return val
-    def MetaDown(self):
-        val = eventsc.wxKeyEvent_MetaDown(self.this)
-        return val
-    def AltDown(self):
-        val = eventsc.wxKeyEvent_AltDown(self.this)
-        return val
-    def ShiftDown(self):
-        val = eventsc.wxKeyEvent_ShiftDown(self.this)
-        return val
-    def KeyCode(self):
-        val = eventsc.wxKeyEvent_KeyCode(self.this)
-        return val
-    def Position(self):
-        val = eventsc.wxKeyEvent_Position(self.this)
-        return val
-    def GetX(self):
-        val = eventsc.wxKeyEvent_GetX(self.this)
-        return val
-    def GetY(self):
-        val = eventsc.wxKeyEvent_GetY(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxKeyEvent instance>"
-class wxKeyEvent(wxKeyEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMoveEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxMoveEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxMoveEvent instance>"
-class wxMoveEvent(wxMoveEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxPaintEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxPaintEvent instance>"
-class wxPaintEvent(wxPaintEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxEraseEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetDC(self):
-        val = eventsc.wxEraseEvent_GetDC(self.this)
-        val = wxDCPtr(val)
-        return val
-    def __repr__(self):
-        return "<C wxEraseEvent instance>"
-class wxEraseEvent(wxEraseEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxFocusEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxFocusEvent instance>"
-class wxFocusEvent(wxFocusEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxActivateEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetActive(self):
-        val = eventsc.wxActivateEvent_GetActive(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxActivateEvent instance>"
-class wxActivateEvent(wxActivateEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxInitDialogEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxInitDialogEvent instance>"
-class wxInitDialogEvent(wxInitDialogEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMenuEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetMenuId(self):
-        val = eventsc.wxMenuEvent_GetMenuId(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMenuEvent instance>"
-class wxMenuEvent(wxMenuEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxShowEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetShow(self,arg0):
-        val = eventsc.wxShowEvent_SetShow(self.this,arg0)
-        return val
-    def GetShow(self):
-        val = eventsc.wxShowEvent_GetShow(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxShowEvent instance>"
-class wxShowEvent(wxShowEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxIconizeEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxIconizeEvent instance>"
-class wxIconizeEvent(wxIconizeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMaximizeEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxMaximizeEvent instance>"
-class wxMaximizeEvent(wxMaximizeEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxJoystickEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxJoystickEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetZPosition(self):
-        val = eventsc.wxJoystickEvent_GetZPosition(self.this)
-        return val
-    def GetButtonState(self):
-        val = eventsc.wxJoystickEvent_GetButtonState(self.this)
-        return val
-    def GetButtonChange(self):
-        val = eventsc.wxJoystickEvent_GetButtonChange(self.this)
-        return val
-    def GetJoystick(self):
-        val = eventsc.wxJoystickEvent_GetJoystick(self.this)
-        return val
-    def SetJoystick(self,arg0):
-        val = eventsc.wxJoystickEvent_SetJoystick(self.this,arg0)
-        return val
-    def SetButtonState(self,arg0):
-        val = eventsc.wxJoystickEvent_SetButtonState(self.this,arg0)
-        return val
-    def SetButtonChange(self,arg0):
-        val = eventsc.wxJoystickEvent_SetButtonChange(self.this,arg0)
-        return val
-    def SetPosition(self,arg0):
-        val = eventsc.wxJoystickEvent_SetPosition(self.this,arg0.this)
-        return val
-    def SetZPosition(self,arg0):
-        val = eventsc.wxJoystickEvent_SetZPosition(self.this,arg0)
-        return val
-    def IsButton(self):
-        val = eventsc.wxJoystickEvent_IsButton(self.this)
-        return val
-    def IsMove(self):
-        val = eventsc.wxJoystickEvent_IsMove(self.this)
-        return val
-    def IsZMove(self):
-        val = eventsc.wxJoystickEvent_IsZMove(self.this)
-        return val
-    def ButtonDown(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonDown,(self.this,)+args)
-        return val
-    def ButtonUp(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonUp,(self.this,)+args)
-        return val
-    def ButtonIsDown(self,*args):
-        val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxJoystickEvent instance>"
-class wxJoystickEvent(wxJoystickEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxDropFilesEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPosition(self):
-        val = eventsc.wxDropFilesEvent_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetNumberOfFiles(self):
-        val = eventsc.wxDropFilesEvent_GetNumberOfFiles(self.this)
-        return val
-    def GetFiles(self):
-        val = eventsc.wxDropFilesEvent_GetFiles(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxDropFilesEvent instance>"
-class wxDropFilesEvent(wxDropFilesEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxIdleEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def RequestMore(self,*args):
-        val = apply(eventsc.wxIdleEvent_RequestMore,(self.this,)+args)
-        return val
-    def MoreRequested(self):
-        val = eventsc.wxIdleEvent_MoreRequested(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxIdleEvent instance>"
-class wxIdleEvent(wxIdleEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxUpdateUIEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetChecked(self):
-        val = eventsc.wxUpdateUIEvent_GetChecked(self.this)
-        return val
-    def GetEnabled(self):
-        val = eventsc.wxUpdateUIEvent_GetEnabled(self.this)
-        return val
-    def GetText(self):
-        val = eventsc.wxUpdateUIEvent_GetText(self.this)
-        return val
-    def GetSetText(self):
-        val = eventsc.wxUpdateUIEvent_GetSetText(self.this)
-        return val
-    def GetSetChecked(self):
-        val = eventsc.wxUpdateUIEvent_GetSetChecked(self.this)
-        return val
-    def GetSetEnabled(self):
-        val = eventsc.wxUpdateUIEvent_GetSetEnabled(self.this)
-        return val
-    def Check(self,arg0):
-        val = eventsc.wxUpdateUIEvent_Check(self.this,arg0)
-        return val
-    def Enable(self,arg0):
-        val = eventsc.wxUpdateUIEvent_Enable(self.this,arg0)
-        return val
-    def SetText(self,arg0):
-        val = eventsc.wxUpdateUIEvent_SetText(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxUpdateUIEvent instance>"
-class wxUpdateUIEvent(wxUpdateUIEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSysColourChangedEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxSysColourChangedEvent instance>"
-class wxSysColourChangedEvent(wxSysColourChangedEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/frames.py

@@ -1,127 +0,0 @@
-# This file was created automatically by SWIG.
-import framesc
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-
-from stattool import *
-
-from controls import *
-
-from events import *
-import wx
-class wxFramePtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Centre(self,*args):
-        val = apply(framesc.wxFrame_Centre,(self.this,)+args)
-        return val
-    def Command(self,arg0):
-        val = framesc.wxFrame_Command(self.this,arg0)
-        return val
-    def CreateStatusBar(self,*args):
-        val = apply(framesc.wxFrame_CreateStatusBar,(self.this,)+args)
-        val = wxStatusBarPtr(val)
-        return val
-    def CreateToolBar(self,*args):
-        val = apply(framesc.wxFrame_CreateToolBar,(self.this,)+args)
-        val = wxToolBarPtr(val)
-        return val
-    def GetMenuBar(self):
-        val = framesc.wxFrame_GetMenuBar(self.this)
-        val = wxMenuBarPtr(val)
-        return val
-    def GetStatusBar(self):
-        val = framesc.wxFrame_GetStatusBar(self.this)
-        val = wxStatusBarPtr(val)
-        return val
-    def GetTitle(self):
-        val = framesc.wxFrame_GetTitle(self.this)
-        return val
-    def GetToolBar(self):
-        val = framesc.wxFrame_GetToolBar(self.this)
-        val = wxToolBarPtr(val)
-        return val
-    def Iconize(self,arg0):
-        val = framesc.wxFrame_Iconize(self.this,arg0)
-        return val
-    def IsIconized(self):
-        val = framesc.wxFrame_IsIconized(self.this)
-        return val
-    def Maximize(self,arg0):
-        val = framesc.wxFrame_Maximize(self.this,arg0)
-        return val
-    def SetAcceleratorTable(self,arg0):
-        val = framesc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
-        return val
-    def SetIcon(self,arg0):
-        val = framesc.wxFrame_SetIcon(self.this,arg0.this)
-        return val
-    def SetMenuBar(self,arg0):
-        val = framesc.wxFrame_SetMenuBar(self.this,arg0.this)
-        return val
-    def SetStatusBar(self,arg0):
-        val = framesc.wxFrame_SetStatusBar(self.this,arg0.this)
-        return val
-    def SetStatusText(self,arg0,*args):
-        val = apply(framesc.wxFrame_SetStatusText,(self.this,arg0,)+args)
-        return val
-    def SetStatusWidths(self,arg0,*args):
-        val = apply(framesc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
-        return val
-    def SetTitle(self,arg0):
-        val = framesc.wxFrame_SetTitle(self.this,arg0)
-        return val
-    def SetToolBar(self,arg0):
-        val = framesc.wxFrame_SetToolBar(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxFrame instance>"
-class wxFrame(wxFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(framesc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-class wxMiniFramePtr(wxFramePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxMiniFrame instance>"
-class wxMiniFrame(wxMiniFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(framesc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/gdi.py

@@ -1,795 +0,0 @@
-# This file was created automatically by SWIG.
-import gdic
-
-from misc import *
-class wxBitmapPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxBitmap(self.this)
-    def Create(self,arg0,arg1,*args):
-        val = apply(gdic.wxBitmap_Create,(self.this,arg0,arg1,)+args)
-        return val
-    def GetDepth(self):
-        val = gdic.wxBitmap_GetDepth(self.this)
-        return val
-    def GetHeight(self):
-        val = gdic.wxBitmap_GetHeight(self.this)
-        return val
-    def GetPalette(self):
-        val = gdic.wxBitmap_GetPalette(self.this)
-        val = wxPalettePtr(val)
-        return val
-    def GetMask(self):
-        val = gdic.wxBitmap_GetMask(self.this)
-        val = wxMaskPtr(val)
-        return val
-    def GetWidth(self):
-        val = gdic.wxBitmap_GetWidth(self.this)
-        return val
-    def LoadFile(self,arg0,arg1):
-        val = gdic.wxBitmap_LoadFile(self.this,arg0,arg1)
-        return val
-    def Ok(self):
-        val = gdic.wxBitmap_Ok(self.this)
-        return val
-    def SaveFile(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxBitmap_SaveFile,(self.this,arg0,arg1,)+args)
-        return val
-    def SetDepth(self,arg0):
-        val = gdic.wxBitmap_SetDepth(self.this,arg0)
-        return val
-    def SetHeight(self,arg0):
-        val = gdic.wxBitmap_SetHeight(self.this,arg0)
-        return val
-    def SetMask(self,arg0):
-        val = gdic.wxBitmap_SetMask(self.this,arg0.this)
-        return val
-    def SetPalette(self,arg0):
-        val = gdic.wxBitmap_SetPalette(self.this,arg0.this)
-        return val
-    def SetWidth(self,arg0):
-        val = gdic.wxBitmap_SetWidth(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxBitmap instance>"
-class wxBitmap(wxBitmapPtr):
-    def __init__(self,arg0,arg1) :
-        self.this = gdic.new_wxBitmap(arg0,arg1)
-        self.thisown = 1
-
-
-
-
-class wxMaskPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxMask(self.this)
-    def __repr__(self):
-        return "<C wxMask instance>"
-class wxMask(wxMaskPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxMask(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxIconPtr(wxBitmapPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxIcon(self.this)
-    def GetDepth(self):
-        val = gdic.wxIcon_GetDepth(self.this)
-        return val
-    def GetHeight(self):
-        val = gdic.wxIcon_GetHeight(self.this)
-        return val
-    def GetWidth(self):
-        val = gdic.wxIcon_GetWidth(self.this)
-        return val
-    def LoadFile(self,arg0,arg1):
-        val = gdic.wxIcon_LoadFile(self.this,arg0,arg1)
-        return val
-    def Ok(self):
-        val = gdic.wxIcon_Ok(self.this)
-        return val
-    def SetDepth(self,arg0):
-        val = gdic.wxIcon_SetDepth(self.this,arg0)
-        return val
-    def SetHeight(self,arg0):
-        val = gdic.wxIcon_SetHeight(self.this,arg0)
-        return val
-    def SetWidth(self,arg0):
-        val = gdic.wxIcon_SetWidth(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxIcon instance>"
-class wxIcon(wxIconPtr):
-    def __init__(self,arg0,arg1,*args) :
-        self.this = apply(gdic.new_wxIcon,(arg0,arg1,)+args)
-        self.thisown = 1
-
-
-
-
-class wxCursorPtr(wxBitmapPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxCursor(self.this)
-    def Ok(self):
-        val = gdic.wxCursor_Ok(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxCursor instance>"
-class wxCursor(wxCursorPtr):
-    def __init__(self,arg0,arg1,*args) :
-        self.this = apply(gdic.new_wxCursor,(arg0,arg1,)+args)
-        self.thisown = 1
-
-
-
-
-class wxFontPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetFaceName(self):
-        val = gdic.wxFont_GetFaceName(self.this)
-        return val
-    def GetFamily(self):
-        val = gdic.wxFont_GetFamily(self.this)
-        return val
-    def GetFontId(self):
-        val = gdic.wxFont_GetFontId(self.this)
-        return val
-    def GetPointSize(self):
-        val = gdic.wxFont_GetPointSize(self.this)
-        return val
-    def GetStyle(self):
-        val = gdic.wxFont_GetStyle(self.this)
-        return val
-    def GetUnderlined(self):
-        val = gdic.wxFont_GetUnderlined(self.this)
-        return val
-    def GetWeight(self):
-        val = gdic.wxFont_GetWeight(self.this)
-        return val
-    def SetFaceName(self,arg0):
-        val = gdic.wxFont_SetFaceName(self.this,arg0)
-        return val
-    def SetFamily(self,arg0):
-        val = gdic.wxFont_SetFamily(self.this,arg0)
-        return val
-    def SetPointSize(self,arg0):
-        val = gdic.wxFont_SetPointSize(self.this,arg0)
-        return val
-    def SetStyle(self,arg0):
-        val = gdic.wxFont_SetStyle(self.this,arg0)
-        return val
-    def SetUnderlined(self,arg0):
-        val = gdic.wxFont_SetUnderlined(self.this,arg0)
-        return val
-    def SetWeight(self,arg0):
-        val = gdic.wxFont_SetWeight(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxFont instance>"
-class wxFont(wxFontPtr):
-    def __init__(self,arg0,arg1,arg2,arg3,*args) :
-        self.this = apply(gdic.new_wxFont,(arg0,arg1,arg2,arg3,)+args)
-        self.thisown = 1
-
-
-
-
-class wxColourPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxColour(self.this)
-    def Red(self):
-        val = gdic.wxColour_Red(self.this)
-        return val
-    def Green(self):
-        val = gdic.wxColour_Green(self.this)
-        return val
-    def Blue(self):
-        val = gdic.wxColour_Blue(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxColour_Ok(self.this)
-        return val
-    def Set(self,arg0,arg1,arg2):
-        val = gdic.wxColour_Set(self.this,arg0,arg1,arg2)
-        return val
-    def Get(self):
-        val = gdic.wxColour_Get(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxColour instance>"
-class wxColour(wxColourPtr):
-    def __init__(self,*args) :
-        self.this = apply(gdic.new_wxColour,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPenPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetCap(self):
-        val = gdic.wxPen_GetCap(self.this)
-        return val
-    def GetColour(self):
-        val = gdic.wxPen_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetJoin(self):
-        val = gdic.wxPen_GetJoin(self.this)
-        return val
-    def GetStyle(self):
-        val = gdic.wxPen_GetStyle(self.this)
-        return val
-    def GetWidth(self):
-        val = gdic.wxPen_GetWidth(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxPen_Ok(self.this)
-        return val
-    def SetCap(self,arg0):
-        val = gdic.wxPen_SetCap(self.this,arg0)
-        return val
-    def SetColour(self,arg0):
-        val = gdic.wxPen_SetColour(self.this,arg0.this)
-        return val
-    def SetJoin(self,arg0):
-        val = gdic.wxPen_SetJoin(self.this,arg0)
-        return val
-    def SetStyle(self,arg0):
-        val = gdic.wxPen_SetStyle(self.this,arg0)
-        return val
-    def SetWidth(self,arg0):
-        val = gdic.wxPen_SetWidth(self.this,arg0)
-        return val
-    def GetDashes(self,arg0):
-        val = gdic.wxPen_GetDashes(self.this,arg0)
-        return val
-    def GetStipple(self):
-        val = gdic.wxPen_GetStipple(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def SetDashes(self,arg0,*args):
-        val = apply(gdic.wxPen_SetDashes,(self.this,arg0,)+args)
-        return val
-    def SetStipple(self,arg0):
-        val = gdic.wxPen_SetStipple(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxPen instance>"
-class wxPen(wxPenPtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(gdic.new_wxPen,(arg0.this,)+args)
-        self.thisown = 1
-
-
-
-
-class wxBrushPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetColour(self):
-        val = gdic.wxBrush_GetColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetStipple(self):
-        val = gdic.wxBrush_GetStipple(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def GetStyle(self):
-        val = gdic.wxBrush_GetStyle(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxBrush_Ok(self.this)
-        return val
-    def SetColour(self,arg0):
-        val = gdic.wxBrush_SetColour(self.this,arg0.this)
-        return val
-    def SetStipple(self,arg0):
-        val = gdic.wxBrush_SetStipple(self.this,arg0.this)
-        return val
-    def SetStyle(self,arg0):
-        val = gdic.wxBrush_SetStyle(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxBrush instance>"
-class wxBrush(wxBrushPtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(gdic.new_wxBrush,(arg0.this,)+args)
-        self.thisown = 1
-
-
-
-
-class wxDCPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxDC(self.this)
-    def BeginDrawing(self):
-        val = gdic.wxDC_BeginDrawing(self.this)
-        return val
-    def Blit(self,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7):
-        val = gdic.wxDC_Blit(self.this,arg0,arg1,arg2,arg3,arg4.this,arg5,arg6,arg7)
-        return val
-    def Clear(self):
-        val = gdic.wxDC_Clear(self.this)
-        return val
-    def CrossHair(self,arg0,arg1):
-        val = gdic.wxDC_CrossHair(self.this,arg0,arg1)
-        return val
-    def DestroyClippingRegion(self):
-        val = gdic.wxDC_DestroyClippingRegion(self.this)
-        return val
-    def DeviceToLogicalX(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalX(self.this,arg0)
-        return val
-    def DeviceToLogicalXRel(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalXRel(self.this,arg0)
-        return val
-    def DeviceToLogicalY(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalY(self.this,arg0)
-        return val
-    def DeviceToLogicalYRel(self,arg0):
-        val = gdic.wxDC_DeviceToLogicalYRel(self.this,arg0)
-        return val
-    def DrawArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
-        val = gdic.wxDC_DrawArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
-        return val
-    def DrawEllipse(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_DrawEllipse(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def DrawEllipticArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
-        val = gdic.wxDC_DrawEllipticArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
-        return val
-    def DrawIcon(self,arg0,arg1,arg2):
-        val = gdic.wxDC_DrawIcon(self.this,arg0.this,arg1,arg2)
-        return val
-    def DrawLine(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_DrawLine(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def DrawLines(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxDC_DrawLines,(self.this,arg0,)+args)
-        return val
-    def DrawPolygon(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxDC_DrawPolygon,(self.this,arg0,)+args)
-        return val
-    def DrawPoint(self,arg0,arg1):
-        val = gdic.wxDC_DrawPoint(self.this,arg0,arg1)
-        return val
-    def DrawRectangle(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_DrawRectangle(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def DrawRoundedRectangle(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(gdic.wxDC_DrawRoundedRectangle,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def DrawSpline(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxDC_DrawSpline,(self.this,arg0,)+args)
-        return val
-    def DrawText(self,arg0,arg1,arg2):
-        val = gdic.wxDC_DrawText(self.this,arg0,arg1,arg2)
-        return val
-    def EndDoc(self):
-        val = gdic.wxDC_EndDoc(self.this)
-        return val
-    def EndDrawing(self):
-        val = gdic.wxDC_EndDrawing(self.this)
-        return val
-    def EndPage(self):
-        val = gdic.wxDC_EndPage(self.this)
-        return val
-    def FloodFill(self,arg0,arg1,arg2,*args):
-        val = apply(gdic.wxDC_FloodFill,(self.this,arg0,arg1,arg2.this,)+args)
-        return val
-    def GetBackground(self):
-        val = gdic.wxDC_GetBackground(self.this)
-        val = wxBrushPtr(val)
-        return val
-    def GetBrush(self):
-        val = gdic.wxDC_GetBrush(self.this)
-        val = wxBrushPtr(val)
-        return val
-    def GetCharHeight(self):
-        val = gdic.wxDC_GetCharHeight(self.this)
-        return val
-    def GetCharWidth(self):
-        val = gdic.wxDC_GetCharWidth(self.this)
-        return val
-    def GetClippingBox(self):
-        val = gdic.wxDC_GetClippingBox(self.this)
-        return val
-    def GetFont(self):
-        val = gdic.wxDC_GetFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetLogicalFunction(self):
-        val = gdic.wxDC_GetLogicalFunction(self.this)
-        return val
-    def GetMapMode(self):
-        val = gdic.wxDC_GetMapMode(self.this)
-        return val
-    def GetOptimization(self):
-        val = gdic.wxDC_GetOptimization(self.this)
-        return val
-    def GetPen(self):
-        val = gdic.wxDC_GetPen(self.this)
-        val = wxPenPtr(val)
-        return val
-    def GetPixel(self,arg0,arg1):
-        val = gdic.wxDC_GetPixel(self.this,arg0,arg1)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def GetSize(self):
-        val = gdic.wxDC_GetSize(self.this)
-        return val
-    def GetTextBackground(self):
-        val = gdic.wxDC_GetTextBackground(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetTextExtent(self,arg0):
-        val = gdic.wxDC_GetTextExtent(self.this,arg0)
-        return val
-    def GetTextForeground(self):
-        val = gdic.wxDC_GetTextForeground(self.this)
-        val = wxColourPtr(val)
-        return val
-    def LogicalToDeviceX(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceX(self.this,arg0)
-        return val
-    def LogicalToDeviceXRel(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceXRel(self.this,arg0)
-        return val
-    def LogicalToDeviceY(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceY(self.this,arg0)
-        return val
-    def LogicalToDeviceYRel(self,arg0):
-        val = gdic.wxDC_LogicalToDeviceYRel(self.this,arg0)
-        return val
-    def MaxX(self):
-        val = gdic.wxDC_MaxX(self.this)
-        return val
-    def MaxY(self):
-        val = gdic.wxDC_MaxY(self.this)
-        return val
-    def MinX(self):
-        val = gdic.wxDC_MinX(self.this)
-        return val
-    def MinY(self):
-        val = gdic.wxDC_MinY(self.this)
-        return val
-    def Ok(self):
-        val = gdic.wxDC_Ok(self.this)
-        return val
-    def SetDeviceOrigin(self,arg0,arg1):
-        val = gdic.wxDC_SetDeviceOrigin(self.this,arg0,arg1)
-        return val
-    def SetBackground(self,arg0):
-        val = gdic.wxDC_SetBackground(self.this,arg0.this)
-        return val
-    def SetBackgroundMode(self,arg0):
-        val = gdic.wxDC_SetBackgroundMode(self.this,arg0)
-        return val
-    def SetClippingRegion(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxDC_SetClippingRegion(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def SetPalette(self,arg0):
-        val = gdic.wxDC_SetPalette(self.this,arg0.this)
-        return val
-    def SetBrush(self,arg0):
-        val = gdic.wxDC_SetBrush(self.this,arg0.this)
-        return val
-    def SetFont(self,arg0):
-        val = gdic.wxDC_SetFont(self.this,arg0.this)
-        return val
-    def SetLogicalFunction(self,arg0):
-        val = gdic.wxDC_SetLogicalFunction(self.this,arg0)
-        return val
-    def SetMapMode(self,arg0):
-        val = gdic.wxDC_SetMapMode(self.this,arg0)
-        return val
-    def SetOptimization(self,arg0):
-        val = gdic.wxDC_SetOptimization(self.this,arg0)
-        return val
-    def SetPen(self,arg0):
-        val = gdic.wxDC_SetPen(self.this,arg0.this)
-        return val
-    def SetTextBackground(self,arg0):
-        val = gdic.wxDC_SetTextBackground(self.this,arg0.this)
-        return val
-    def SetTextForeground(self,arg0):
-        val = gdic.wxDC_SetTextForeground(self.this,arg0.this)
-        return val
-    def SetUserScale(self,arg0,arg1):
-        val = gdic.wxDC_SetUserScale(self.this,arg0,arg1)
-        return val
-    def StartDoc(self,arg0):
-        val = gdic.wxDC_StartDoc(self.this,arg0)
-        return val
-    def StartPage(self):
-        val = gdic.wxDC_StartPage(self.this)
-        return val
-    def DrawBitmap(self,arg0,arg1,arg2,*args):
-        val = apply(gdic.wxDC_DrawBitmap,(self.this,arg0.this,arg1,arg2,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxDC instance>"
-class wxDC(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxMemoryDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SelectObject(self,arg0):
-        val = gdic.wxMemoryDC_SelectObject(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxMemoryDC instance>"
-class wxMemoryDC(wxMemoryDCPtr):
-    def __init__(self) :
-        self.this = gdic.new_wxMemoryDC()
-        self.thisown = 1
-
-
-
-
-class wxScreenDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def StartDrawingOnTop(self,arg0):
-        val = gdic.wxScreenDC_StartDrawingOnTop(self.this,arg0.this)
-        return val
-    def StartDrawingOnTopRect(self,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(gdic.wxScreenDC_StartDrawingOnTopRect,(self.this,)+args)
-        return val
-    def EndDrawingOnTop(self):
-        val = gdic.wxScreenDC_EndDrawingOnTop(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxScreenDC instance>"
-class wxScreenDC(wxScreenDCPtr):
-    def __init__(self) :
-        self.this = gdic.new_wxScreenDC()
-        self.thisown = 1
-
-
-
-
-class wxClientDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxClientDC instance>"
-class wxClientDC(wxClientDCPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxClientDC(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxPaintDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxPaintDC instance>"
-class wxPaintDC(wxPaintDCPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxPaintDC(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxWindowDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxWindowDC instance>"
-class wxWindowDC(wxWindowDCPtr):
-    def __init__(self,arg0) :
-        self.this = gdic.new_wxWindowDC(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxPrinterDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxPrinterDC instance>"
-class wxPrinterDC(wxPrinterDCPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        self.this = apply(gdic.new_wxPrinterDC,(arg0,arg1,arg2,)+args)
-        self.thisown = 1
-
-
-
-
-class wxMetaFileDCPtr(wxDCPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Close(self):
-        val = gdic.wxMetaFileDC_Close(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMetaFileDC instance>"
-class wxMetaFileDC(wxMetaFileDCPtr):
-    def __init__(self,*args) :
-        self.this = apply(gdic.new_wxMetaFileDC,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPalettePtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            gdic.delete_wxPalette(self.this)
-    def GetPixel(self,arg0,arg1,arg2):
-        val = gdic.wxPalette_GetPixel(self.this,arg0,arg1,arg2)
-        return val
-    def GetRGB(self,arg0,arg1,arg2,arg3):
-        val = gdic.wxPalette_GetRGB(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def Ok(self):
-        val = gdic.wxPalette_Ok(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPalette instance>"
-class wxPalette(wxPalettePtr):
-    def __init__(self,arg0,arg1,arg2) :
-        self.this = gdic.new_wxPalette(arg0,arg1,arg2)
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-def wxEmptyBitmap(arg0,arg1,*args):
-    val = apply(gdic.wxEmptyBitmap,(arg0,arg1,)+args)
-    val = wxBitmapPtr(val)
-    val.thisown = 1
-    return val
-
-def wxNoRefBitmap(arg0,arg1):
-    val = gdic.wxNoRefBitmap(arg0,arg1)
-    val = wxBitmapPtr(val)
-    return val
-
-def wxMaskColour(arg0,arg1):
-    val = gdic.wxMaskColour(arg0.this,arg1.this)
-    val = wxMaskPtr(val)
-    val.thisown = 1
-    return val
-
-def wxStockCursor(arg0):
-    val = gdic.wxStockCursor(arg0)
-    val = wxCursorPtr(val)
-    val.thisown = 1
-    return val
-
-def wxNamedColour(arg0):
-    val = gdic.wxNamedColour(arg0)
-    val = wxColourPtr(val)
-    val.thisown = 1
-    return val
-
-def wxMemoryDCFromDC(arg0):
-    val = gdic.wxMemoryDCFromDC(arg0.this)
-    val = wxMemoryDCPtr(val)
-    val.thisown = 1
-    return val
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-cvar = gdic.cvar
-wxNORMAL_FONT = wxFontPtr(gdic.cvar.wxNORMAL_FONT)
-wxSMALL_FONT = wxFontPtr(gdic.cvar.wxSMALL_FONT)
-wxITALIC_FONT = wxFontPtr(gdic.cvar.wxITALIC_FONT)
-wxSWISS_FONT = wxFontPtr(gdic.cvar.wxSWISS_FONT)
-wxRED_PEN = wxPenPtr(gdic.cvar.wxRED_PEN)
-wxCYAN_PEN = wxPenPtr(gdic.cvar.wxCYAN_PEN)
-wxGREEN_PEN = wxPenPtr(gdic.cvar.wxGREEN_PEN)
-wxBLACK_PEN = wxPenPtr(gdic.cvar.wxBLACK_PEN)
-wxWHITE_PEN = wxPenPtr(gdic.cvar.wxWHITE_PEN)
-wxTRANSPARENT_PEN = wxPenPtr(gdic.cvar.wxTRANSPARENT_PEN)
-wxBLACK_DASHED_PEN = wxPenPtr(gdic.cvar.wxBLACK_DASHED_PEN)
-wxGREY_PEN = wxPenPtr(gdic.cvar.wxGREY_PEN)
-wxMEDIUM_GREY_PEN = wxPenPtr(gdic.cvar.wxMEDIUM_GREY_PEN)
-wxLIGHT_GREY_PEN = wxPenPtr(gdic.cvar.wxLIGHT_GREY_PEN)
-wxBLUE_BRUSH = wxBrushPtr(gdic.cvar.wxBLUE_BRUSH)
-wxGREEN_BRUSH = wxBrushPtr(gdic.cvar.wxGREEN_BRUSH)
-wxWHITE_BRUSH = wxBrushPtr(gdic.cvar.wxWHITE_BRUSH)
-wxBLACK_BRUSH = wxBrushPtr(gdic.cvar.wxBLACK_BRUSH)
-wxTRANSPARENT_BRUSH = wxBrushPtr(gdic.cvar.wxTRANSPARENT_BRUSH)
-wxCYAN_BRUSH = wxBrushPtr(gdic.cvar.wxCYAN_BRUSH)
-wxRED_BRUSH = wxBrushPtr(gdic.cvar.wxRED_BRUSH)
-wxGREY_BRUSH = wxBrushPtr(gdic.cvar.wxGREY_BRUSH)
-wxMEDIUM_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxMEDIUM_GREY_BRUSH)
-wxLIGHT_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxLIGHT_GREY_BRUSH)
-wxBLACK = wxColourPtr(gdic.cvar.wxBLACK)
-wxWHITE = wxColourPtr(gdic.cvar.wxWHITE)
-wxRED = wxColourPtr(gdic.cvar.wxRED)
-wxBLUE = wxColourPtr(gdic.cvar.wxBLUE)
-wxGREEN = wxColourPtr(gdic.cvar.wxGREEN)
-wxCYAN = wxColourPtr(gdic.cvar.wxCYAN)
-wxLIGHT_GREY = wxColourPtr(gdic.cvar.wxLIGHT_GREY)
-wxSTANDARD_CURSOR = wxCursorPtr(gdic.cvar.wxSTANDARD_CURSOR)
-wxHOURGLASS_CURSOR = wxCursorPtr(gdic.cvar.wxHOURGLASS_CURSOR)
-wxCROSS_CURSOR = wxCursorPtr(gdic.cvar.wxCROSS_CURSOR)
-wxNullBitmap = wxBitmapPtr(gdic.cvar.wxNullBitmap)
-wxNullIcon = wxIconPtr(gdic.cvar.wxNullIcon)
-wxNullCursor = wxCursorPtr(gdic.cvar.wxNullCursor)
-wxNullPen = wxPenPtr(gdic.cvar.wxNullPen)
-wxNullBrush = wxBrushPtr(gdic.cvar.wxNullBrush)
-wxNullFont = wxFontPtr(gdic.cvar.wxNullFont)
-wxNullColour = wxColourPtr(gdic.cvar.wxNullColour)

utils/wxPython/src/msw/mdi.cpp

@@ -1,995 +0,0 @@
-/*
- * FILE : msw/mdi.cpp
- * 
- * This file was automatically generated by :
- * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Patch 5)
- * 
- * Portions Copyright (c) 1995-1998
- * The University of Utah and The Regents of the University of California.
- * Permission is granted to distribute this file in any manner provided
- * this notice remains intact.
- * 
- * Do not make changes to this file--changes will be lost!
- *
- */
-
-
-#define SWIGCODE
-/* Implementation : PYTHON */
-
-#define SWIGPYTHON
-#include <string.h>
-#include <stdlib.h>
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a,b) __declspec(dllexport) a b
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a,b) a _export b
-#	else
-#	    define SWIGEXPORT(a,b) a b
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a,b) a b
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "Python.h"
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif
-
-#define SWIG_init    initmdic
-
-#define SWIG_name    "mdic"
-
-#include "helpers.h"
-
-static PyObject* l_output_helper(PyObject* target, PyObject* o) {
-    PyObject*   o2;
-    if (!target) {
-        target = o;
-    } else if (target == Py_None) {
-        Py_DECREF(Py_None);
-        target = o;
-    } else {
-        if (!PyList_Check(target)) {
-            o2 = target;
-            target = PyList_New(0);
-            PyList_Append(target, o2);
-	    Py_XDECREF(o2);
-        }
-        PyList_Append(target,o);
-	Py_XDECREF(o);
-    }
-    return target;
-}
-
-static PyObject* t_output_helper(PyObject* target, PyObject* o) {
-    PyObject*   o2;
-    PyObject*   o3;
-
-    if (!target) {
-        target = o;
-    } else if (target == Py_None) {
-        Py_DECREF(Py_None);
-        target = o;
-    } else {
-        if (!PyTuple_Check(target)) {
-            o2 = target;
-            target = PyTuple_New(1);
-            PyTuple_SetItem(target, 0, o2);
-        }
-        o3 = PyTuple_New(1);
-        PyTuple_SetItem(o3, 0, o);
-
-        o2 = target;
-        target = PySequence_Concat(o2, o3);
-        Py_DECREF(o2);
-        Py_DECREF(o3);
-    }
-    return target;
-}
-
-
-extern byte* byte_LIST_helper(PyObject* source);
-extern int* int_LIST_helper(PyObject* source);
-extern long* long_LIST_helper(PyObject* source);
-extern char** string_LIST_helper(PyObject* source);
-extern wxPoint* wxPoint_LIST_helper(PyObject* source);
-extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-extern wxString* wxString_LIST_helper(PyObject* source);
-extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
-static char* wxStringErrorMsg = "string type is required for parameter";
-static void *SwigwxMDIParentFrameTowxFrame(void *ptr) {
-    wxMDIParentFrame *src;
-    wxFrame *dest;
-    src = (wxMDIParentFrame *) ptr;
-    dest = (wxFrame *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIParentFrameTowxWindow(void *ptr) {
-    wxMDIParentFrame *src;
-    wxWindow *dest;
-    src = (wxMDIParentFrame *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIParentFrameTowxEvtHandler(void *ptr) {
-    wxMDIParentFrame *src;
-    wxEvtHandler *dest;
-    src = (wxMDIParentFrame *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-#define new_wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
-static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _result;
-    wxWindow * _arg0;
-    wxWindowID  _arg1;
-    wxString * _arg2;
-    wxPoint * _arg3 = &wxPyDefaultPosition;
-    wxSize * _arg4 = &wxPyDefaultSize;
-    long  _arg5 = (wxDEFAULT_FRAME_STYLE)|(wxVSCROLL)|(wxHSCROLL);
-    char * _arg6 = "frame";
-    char * _argc0 = 0;
-    PyObject * _obj2 = 0;
-    char * _argc3 = 0;
-    char * _argc4 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIParentFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIParentFrame. Expected _wxWindow_p.");
-        return NULL;
-        }
-    }
-{
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AsString(_obj2));
-}
-    if (_argc3) {
-        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIParentFrame. Expected _wxPoint_p.");
-        return NULL;
-        }
-    }
-    if (_argc4) {
-        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIParentFrame. Expected _wxSize_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-{
-    if (_obj2)
-        delete _arg2;
-}
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_ActivateNext(_swigobj)  (_swigobj->ActivateNext())
-static PyObject *_wrap_wxMDIParentFrame_ActivateNext(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivateNext",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivateNext. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_ActivateNext(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_ActivatePrevious(_swigobj)  (_swigobj->ActivatePrevious())
-static PyObject *_wrap_wxMDIParentFrame_ActivatePrevious(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivatePrevious",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivatePrevious. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_ActivatePrevious(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_ArrangeIcons(_swigobj)  (_swigobj->ArrangeIcons())
-static PyObject *_wrap_wxMDIParentFrame_ArrangeIcons(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ArrangeIcons",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ArrangeIcons. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_ArrangeIcons(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_Cascade(_swigobj)  (_swigobj->Cascade())
-static PyObject *_wrap_wxMDIParentFrame_Cascade(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Cascade",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Cascade. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_Cascade(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetClientSize(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxMDIParentFrame_GetClientSize(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    int * _arg1;
-    int  temp;
-    int * _arg2;
-    int  temp0;
-    char * _argc0 = 0;
-
-    self = self;
-{
-  _arg1 = &temp;
-}
-{
-  _arg2 = &temp0;
-}
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientSize",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientSize. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_GetClientSize(_arg0,_arg1,_arg2);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg1));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg2));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetActiveChild(_swigobj)  (_swigobj->GetActiveChild())
-static PyObject *_wrap_wxMDIParentFrame_GetActiveChild(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _result;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetActiveChild",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetActiveChild. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetClientWindow(_swigobj)  (_swigobj->GetClientWindow())
-static PyObject *_wrap_wxMDIParentFrame_GetClientWindow(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIClientWindow * _result;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientWindow",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientWindow. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_GetToolBar(_swigobj)  (_swigobj->GetToolBar())
-static PyObject *_wrap_wxMDIParentFrame_GetToolBar(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxWindow * _result;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetToolBar",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetToolBar. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_SetToolBar(_swigobj,_swigarg0)  (_swigobj->SetToolBar(_swigarg0))
-static PyObject *_wrap_wxMDIParentFrame_SetToolBar(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    wxToolBar * _arg1;
-    char * _argc0 = 0;
-    char * _argc1 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"ss:wxMDIParentFrame_SetToolBar",&_argc0,&_argc1)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_SetToolBar. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    if (_argc1) {
-        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxToolBar_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIParentFrame_SetToolBar. Expected _wxToolBar_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_SetToolBar(_arg0,_arg1);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIParentFrame_Tile(_swigobj)  (_swigobj->Tile())
-static PyObject *_wrap_wxMDIParentFrame_Tile(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIParentFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Tile",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Tile. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIParentFrame_Tile(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-static void *SwigwxMDIChildFrameTowxFrame(void *ptr) {
-    wxMDIChildFrame *src;
-    wxFrame *dest;
-    src = (wxMDIChildFrame *) ptr;
-    dest = (wxFrame *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIChildFrameTowxWindow(void *ptr) {
-    wxMDIChildFrame *src;
-    wxWindow *dest;
-    src = (wxMDIChildFrame *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIChildFrameTowxEvtHandler(void *ptr) {
-    wxMDIChildFrame *src;
-    wxEvtHandler *dest;
-    src = (wxMDIChildFrame *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-#define new_wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
-static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _result;
-    wxMDIParentFrame * _arg0;
-    wxWindowID  _arg1;
-    wxString * _arg2;
-    wxPoint * _arg3 = &wxPyDefaultPosition;
-    wxSize * _arg4 = &wxPyDefaultSize;
-    long  _arg5 = (wxDEFAULT_FRAME_STYLE);
-    char * _arg6 = "frame";
-    char * _argc0 = 0;
-    PyObject * _obj2 = 0;
-    char * _argc3 = 0;
-    char * _argc4 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIChildFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIChildFrame. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-{
-    if (!PyString_Check(_obj2)) {
-        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
-        return NULL;
-    }
-    _arg2 = new wxString(PyString_AsString(_obj2));
-}
-    if (_argc3) {
-        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIChildFrame. Expected _wxPoint_p.");
-        return NULL;
-        }
-    }
-    if (_argc4) {
-        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIChildFrame. Expected _wxSize_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-{
-    if (_obj2)
-        delete _arg2;
-}
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_Activate(_swigobj)  (_swigobj->Activate())
-static PyObject *_wrap_wxMDIChildFrame_Activate(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Activate",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Activate. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_Activate(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_Maximize(_swigobj)  (_swigobj->Maximize())
-static PyObject *_wrap_wxMDIChildFrame_Maximize(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Maximize",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Maximize. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_Maximize(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_Restore(_swigobj)  (_swigobj->Restore())
-static PyObject *_wrap_wxMDIChildFrame_Restore(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Restore",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Restore. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_Restore(_arg0);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_SetMenuBar(_swigobj,_swigarg0)  (_swigobj->SetMenuBar(_swigarg0))
-static PyObject *_wrap_wxMDIChildFrame_SetMenuBar(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    wxMenuBar * _arg1;
-    char * _argc0 = 0;
-    char * _argc1 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"ss:wxMDIChildFrame_SetMenuBar",&_argc0,&_argc1)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetMenuBar. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    if (_argc1) {
-        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxMenuBar_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIChildFrame_SetMenuBar. Expected _wxMenuBar_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_SetMenuBar(_arg0,_arg1);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_SetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetClientSize(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxMDIChildFrame_SetClientSize(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    int  _arg1;
-    int  _arg2;
-    char * _argc0 = 0;
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"sii:wxMDIChildFrame_SetClientSize",&_argc0,&_arg1,&_arg2)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetClientSize. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_SetClientSize(_arg0,_arg1,_arg2);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxMDIChildFrame_GetPosition(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetPosition(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxMDIChildFrame_GetPosition(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIChildFrame * _arg0;
-    int * _arg1;
-    int  temp;
-    int * _arg2;
-    int  temp0;
-    char * _argc0 = 0;
-
-    self = self;
-{
-  _arg1 = &temp;
-}
-{
-  _arg2 = &temp0;
-}
-    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_GetPosition",&_argc0)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_GetPosition. Expected _wxMDIChildFrame_p.");
-        return NULL;
-        }
-    }
-    wxMDIChildFrame_GetPosition(_arg0,_arg1,_arg2);
-    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg1));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*_arg2));
-    _resultobj = t_output_helper(_resultobj, o);
-}
-    return _resultobj;
-}
-
-static void *SwigwxMDIClientWindowTowxWindow(void *ptr) {
-    wxMDIClientWindow *src;
-    wxWindow *dest;
-    src = (wxMDIClientWindow *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxMDIClientWindowTowxEvtHandler(void *ptr) {
-    wxMDIClientWindow *src;
-    wxEvtHandler *dest;
-    src = (wxMDIClientWindow *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-#define new_wxMDIClientWindow(_swigarg0,_swigarg1) (new wxMDIClientWindow(_swigarg0,_swigarg1))
-static PyObject *_wrap_new_wxMDIClientWindow(PyObject *self, PyObject *args) {
-    PyObject * _resultobj;
-    wxMDIClientWindow * _result;
-    wxMDIParentFrame * _arg0;
-    long  _arg1 = 0;
-    char * _argc0 = 0;
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTuple(args,"s|l:new_wxMDIClientWindow",&_argc0,&_arg1)) 
-        return NULL;
-    if (_argc0) {
-        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIClientWindow. Expected _wxMDIParentFrame_p.");
-        return NULL;
-        }
-    }
-    _result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1);
-    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
-    _resultobj = Py_BuildValue("s",_ptemp);
-    return _resultobj;
-}
-
-static PyMethodDef mdicMethods[] = {
-	 { "new_wxMDIClientWindow", _wrap_new_wxMDIClientWindow, 1 },
-	 { "wxMDIChildFrame_GetPosition", _wrap_wxMDIChildFrame_GetPosition, 1 },
-	 { "wxMDIChildFrame_SetClientSize", _wrap_wxMDIChildFrame_SetClientSize, 1 },
-	 { "wxMDIChildFrame_SetMenuBar", _wrap_wxMDIChildFrame_SetMenuBar, 1 },
-	 { "wxMDIChildFrame_Restore", _wrap_wxMDIChildFrame_Restore, 1 },
-	 { "wxMDIChildFrame_Maximize", _wrap_wxMDIChildFrame_Maximize, 1 },
-	 { "wxMDIChildFrame_Activate", _wrap_wxMDIChildFrame_Activate, 1 },
-	 { "new_wxMDIChildFrame", _wrap_new_wxMDIChildFrame, 1 },
-	 { "wxMDIParentFrame_Tile", _wrap_wxMDIParentFrame_Tile, 1 },
-	 { "wxMDIParentFrame_SetToolBar", _wrap_wxMDIParentFrame_SetToolBar, 1 },
-	 { "wxMDIParentFrame_GetToolBar", _wrap_wxMDIParentFrame_GetToolBar, 1 },
-	 { "wxMDIParentFrame_GetClientWindow", _wrap_wxMDIParentFrame_GetClientWindow, 1 },
-	 { "wxMDIParentFrame_GetActiveChild", _wrap_wxMDIParentFrame_GetActiveChild, 1 },
-	 { "wxMDIParentFrame_GetClientSize", _wrap_wxMDIParentFrame_GetClientSize, 1 },
-	 { "wxMDIParentFrame_Cascade", _wrap_wxMDIParentFrame_Cascade, 1 },
-	 { "wxMDIParentFrame_ArrangeIcons", _wrap_wxMDIParentFrame_ArrangeIcons, 1 },
-	 { "wxMDIParentFrame_ActivatePrevious", _wrap_wxMDIParentFrame_ActivatePrevious, 1 },
-	 { "wxMDIParentFrame_ActivateNext", _wrap_wxMDIParentFrame_ActivateNext, 1 },
-	 { "new_wxMDIParentFrame", _wrap_new_wxMDIParentFrame, 1 },
-	 { NULL, NULL }
-};
-static PyObject *SWIG_globals;
-#ifdef __cplusplus
-extern "C" 
-#endif
-SWIGEXPORT(void,initmdic)() {
-	 PyObject *m, *d;
-	 SWIG_globals = SWIG_newvarlink();
-	 m = Py_InitModule("mdic", mdicMethods);
-	 d = PyModule_GetDict(m);
-/*
- * These are the pointer type-equivalency mappings. 
- * (Used by the SWIG pointer type-checker).
- */
-	 SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
-	 SWIG_RegisterMapping("_wxEvent","_class_wxEvent",0);
-	 SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
-	 SWIG_RegisterMapping("_signed_long","_long",0);
-	 SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
-	 SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
-	 SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
-	 SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
-	 SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
-	 SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
-	 SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
-	 SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
-	 SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
-	 SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
-	 SWIG_RegisterMapping("_byte","_unsigned_char",0);
-	 SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0);
-	 SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
-	 SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
-	 SWIG_RegisterMapping("_long","_wxDash",0);
-	 SWIG_RegisterMapping("_long","_unsigned_long",0);
-	 SWIG_RegisterMapping("_long","_signed_long",0);
-	 SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0);
-	 SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0);
-	 SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
-	 SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
-	 SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
-	 SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
-	 SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
-	 SWIG_RegisterMapping("_wxPrinterDC","_class_wxPrinterDC",0);
-	 SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
-	 SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0);
-	 SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0);
-	 SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0);
-	 SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
-	 SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0);
-	 SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0);
-	 SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0);
-	 SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
-	 SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0);
-	 SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
-	 SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
-	 SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
-	 SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
-	 SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
-	 SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
-	 SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
-	 SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
-	 SWIG_RegisterMapping("_uint","_unsigned_int",0);
-	 SWIG_RegisterMapping("_uint","_int",0);
-	 SWIG_RegisterMapping("_uint","_wxWindowID",0);
-	 SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
-	 SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
-	 SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
-	 SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
-	 SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0);
-	 SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
-	 SWIG_RegisterMapping("_class_wxButton","_wxButton",0);
-	 SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0);
-	 SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
-	 SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
-	 SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
-	 SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
-	 SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
-	 SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
-	 SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
-	 SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
-	 SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
-	 SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
-	 SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
-	 SWIG_RegisterMapping("_EBool","_signed_int",0);
-	 SWIG_RegisterMapping("_EBool","_int",0);
-	 SWIG_RegisterMapping("_EBool","_wxWindowID",0);
-	 SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
-	 SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0);
-	 SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
-	 SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
-	 SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
-	 SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
-	 SWIG_RegisterMapping("_unsigned_long","_long",0);
-	 SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
-	 SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
-	 SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0);
-	 SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
-	 SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0);
-	 SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxSpinButton","_wxSpinButton",0);
-	 SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
-	 SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
-	 SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
-	 SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
-	 SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
-	 SWIG_RegisterMapping("_signed_int","_EBool",0);
-	 SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_signed_int","_int",0);
-	 SWIG_RegisterMapping("_class_wxTextCtrl","_wxTextCtrl",0);
-	 SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
-	 SWIG_RegisterMapping("_wxMetaFileDC","_class_wxMetaFileDC",0);
-	 SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
-	 SWIG_RegisterMapping("_class_wxMoveEvent","_wxMoveEvent",0);
-	 SWIG_RegisterMapping("_wxListBox","_class_wxListBox",0);
-	 SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
-	 SWIG_RegisterMapping("_class_wxMDIChildFrame","_wxMDIChildFrame",0);
-	 SWIG_RegisterMapping("_WXTYPE","_short",0);
-	 SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
-	 SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
-	 SWIG_RegisterMapping("_class_wxMDIClientWindow","_wxMDIClientWindow",0);
-	 SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
-	 SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_unsigned_short","_short",0);
-	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
-	 SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0);
-	 SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
-	 SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0);
-	 SWIG_RegisterMapping("_class_wxMenuEvent","_wxMenuEvent",0);
-	 SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
-	 SWIG_RegisterMapping("_wxMouseEvent","_class_wxMouseEvent",0);
-	 SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
-	 SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
-	 SWIG_RegisterMapping("_class_wxRadioBox","_wxRadioBox",0);
-	 SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_signed_short","_short",0);
-	 SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
-	 SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
-	 SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
-	 SWIG_RegisterMapping("_class_wxFocusEvent","_wxFocusEvent",0);
-	 SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0);
-	 SWIG_RegisterMapping("_wxStatusBar","_class_wxStatusBar",0);
-	 SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0);
-	 SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
-	 SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
-	 SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
-	 SWIG_RegisterMapping("_unsigned_char","_byte",0);
-	 SWIG_RegisterMapping("_class_wxMetaFileDC","_wxMetaFileDC",0);
-	 SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
-	 SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
-	 SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
-	 SWIG_RegisterMapping("_unsigned_int","_uint",0);
-	 SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_unsigned_int","_int",0);
-	 SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
-	 SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
-	 SWIG_RegisterMapping("_class_wxPyMenu","_wxPyMenu",0);
-	 SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
-	 SWIG_RegisterMapping("_short","_WXTYPE",0);
-	 SWIG_RegisterMapping("_short","_unsigned_short",0);
-	 SWIG_RegisterMapping("_short","_signed_short",0);
-	 SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0);
-	 SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
-	 SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
-	 SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0);
-	 SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
-	 SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
-	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
-	 SWIG_RegisterMapping("_wxWindowID","_EBool",0);
-	 SWIG_RegisterMapping("_wxWindowID","_uint",0);
-	 SWIG_RegisterMapping("_wxWindowID","_int",0);
-	 SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
-	 SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
-	 SWIG_RegisterMapping("_int","_EBool",0);
-	 SWIG_RegisterMapping("_int","_uint",0);
-	 SWIG_RegisterMapping("_int","_wxWindowID",0);
-	 SWIG_RegisterMapping("_int","_unsigned_int",0);
-	 SWIG_RegisterMapping("_int","_signed_int",0);
-	 SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0);
-	 SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0);
-	 SWIG_RegisterMapping("_wxButton","_class_wxButton",0);
-	 SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
-	 SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
-	 SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",0);
-	 SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0);
-	 SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
-	 SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0);
-	 SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0);
-	 SWIG_RegisterMapping("_class_wxComboBox","_wxComboBox",0);
-	 SWIG_RegisterMapping("_class_wxRadioButton","_wxRadioButton",0);
-	 SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
-	 SWIG_RegisterMapping("_wxIconizeEvent","_class_wxIconizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxControl","_wxControl",0);
-	 SWIG_RegisterMapping("_wxStaticBitmap","_class_wxStaticBitmap",0);
-	 SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
-	 SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
-	 SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
-	 SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
-	 SWIG_RegisterMapping("_class_wxIdleEvent","_wxIdleEvent",0);
-	 SWIG_RegisterMapping("_wxEraseEvent","_class_wxEraseEvent",0);
-	 SWIG_RegisterMapping("_class_wxJoystickEvent","_wxJoystickEvent",0);
-	 SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0);
-	 SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
-	 SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
-	 SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
-	 SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
-	 SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0);
-	 SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0);
-	 SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
-	 SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0);
-	 SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
-	 SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
-	 SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
-	 SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
-	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
-	 SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
-	 SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0);
-	 SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
-	 SWIG_RegisterMapping("_wxDash","_long",0);
-	 SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
-	 SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0);
-	 SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0);
-	 SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
-	 SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0);
-	 SWIG_RegisterMapping("_wxMDIClientWindow","_class_wxMDIClientWindow",0);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
-	 SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
-	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
-	 SWIG_RegisterMapping("_class_wxFrame","_wxFrame",0);
-}

utils/wxPython/src/msw/mdi.py

@@ -1,134 +0,0 @@
-# This file was created automatically by SWIG.
-import mdic
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from events import *
-import wx
-class wxMDIParentFramePtr(wxFramePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def ActivateNext(self):
-        val = mdic.wxMDIParentFrame_ActivateNext(self.this)
-        return val
-    def ActivatePrevious(self):
-        val = mdic.wxMDIParentFrame_ActivatePrevious(self.this)
-        return val
-    def ArrangeIcons(self):
-        val = mdic.wxMDIParentFrame_ArrangeIcons(self.this)
-        return val
-    def Cascade(self):
-        val = mdic.wxMDIParentFrame_Cascade(self.this)
-        return val
-    def GetClientSize(self):
-        val = mdic.wxMDIParentFrame_GetClientSize(self.this)
-        return val
-    def GetActiveChild(self):
-        val = mdic.wxMDIParentFrame_GetActiveChild(self.this)
-        val = wxMDIChildFramePtr(val)
-        return val
-    def GetClientWindow(self):
-        val = mdic.wxMDIParentFrame_GetClientWindow(self.this)
-        val = wxMDIClientWindowPtr(val)
-        return val
-    def GetToolBar(self):
-        val = mdic.wxMDIParentFrame_GetToolBar(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def SetToolBar(self,arg0):
-        val = mdic.wxMDIParentFrame_SetToolBar(self.this,arg0.this)
-        return val
-    def Tile(self):
-        val = mdic.wxMDIParentFrame_Tile(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMDIParentFrame instance>"
-class wxMDIParentFrame(wxMDIParentFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(mdic.new_wxMDIParentFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-class wxMDIChildFramePtr(wxFramePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Activate(self):
-        val = mdic.wxMDIChildFrame_Activate(self.this)
-        return val
-    def Maximize(self):
-        val = mdic.wxMDIChildFrame_Maximize(self.this)
-        return val
-    def Restore(self):
-        val = mdic.wxMDIChildFrame_Restore(self.this)
-        return val
-    def SetMenuBar(self,arg0):
-        val = mdic.wxMDIChildFrame_SetMenuBar(self.this,arg0.this)
-        return val
-    def SetClientSize(self,arg0,arg1):
-        val = mdic.wxMDIChildFrame_SetClientSize(self.this,arg0,arg1)
-        return val
-    def GetPosition(self):
-        val = mdic.wxMDIChildFrame_GetPosition(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMDIChildFrame instance>"
-class wxMDIChildFrame(wxMDIChildFramePtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(mdic.new_wxMDIChildFrame,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdFrameCallbacks(self)
-
-
-
-
-class wxMDIClientWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxMDIClientWindow instance>"
-class wxMDIClientWindow(wxMDIClientWindowPtr):
-    def __init__(self,arg0,*args) :
-        self.this = apply(mdic.new_wxMDIClientWindow,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._StdOnScrollCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/misc.py

@@ -1,635 +0,0 @@
-# This file was created automatically by SWIG.
-import miscc
-class wxSizePtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxSize(self.this)
-    def Set(self,arg0,arg1):
-        val = miscc.wxSize_Set(self.this,arg0,arg1)
-        return val
-    def GetWidth(self):
-        val = miscc.wxSize_GetWidth(self.this)
-        return val
-    def GetHeight(self):
-        val = miscc.wxSize_GetHeight(self.this)
-        return val
-    def __str__(self):
-        val = miscc.wxSize___str__(self.this)
-        return val
-    def __setattr__(self,name,value):
-        if name == "width" :
-            miscc.wxSize_width_set(self.this,value)
-            return
-        if name == "height" :
-            miscc.wxSize_height_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "width" : 
-            return miscc.wxSize_width_get(self.this)
-        if name == "height" : 
-            return miscc.wxSize_height_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxSize instance>"
-class wxSize(wxSizePtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxSize,()+args)
-        self.thisown = 1
-
-
-
-
-class wxRealPointPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRealPoint(self.this)
-    def __setattr__(self,name,value):
-        if name == "x" :
-            miscc.wxRealPoint_x_set(self.this,value)
-            return
-        if name == "y" :
-            miscc.wxRealPoint_y_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "x" : 
-            return miscc.wxRealPoint_x_get(self.this)
-        if name == "y" : 
-            return miscc.wxRealPoint_y_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxRealPoint instance>"
-class wxRealPoint(wxRealPointPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxRealPoint,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPointPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxPoint(self.this)
-    def Set(self,arg0,arg1):
-        val = miscc.wxPoint_Set(self.this,arg0,arg1)
-        return val
-    def __str__(self):
-        val = miscc.wxPoint___str__(self.this)
-        return val
-    def __setattr__(self,name,value):
-        if name == "x" :
-            miscc.wxPoint_x_set(self.this,value)
-            return
-        if name == "y" :
-            miscc.wxPoint_y_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "x" : 
-            return miscc.wxPoint_x_get(self.this)
-        if name == "y" : 
-            return miscc.wxPoint_y_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxPoint instance>"
-class wxPoint(wxPointPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxPoint,()+args)
-        self.thisown = 1
-
-
-
-
-class wxRectPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRect(self.this)
-    def GetX(self):
-        val = miscc.wxRect_GetX(self.this)
-        return val
-    def SetX(self,arg0):
-        val = miscc.wxRect_SetX(self.this,arg0)
-        return val
-    def GetY(self):
-        val = miscc.wxRect_GetY(self.this)
-        return val
-    def SetY(self,arg0):
-        val = miscc.wxRect_SetY(self.this,arg0)
-        return val
-    def GetWidth(self):
-        val = miscc.wxRect_GetWidth(self.this)
-        return val
-    def SetWidth(self,arg0):
-        val = miscc.wxRect_SetWidth(self.this,arg0)
-        return val
-    def GetHeight(self):
-        val = miscc.wxRect_GetHeight(self.this)
-        return val
-    def SetHeight(self,arg0):
-        val = miscc.wxRect_SetHeight(self.this,arg0)
-        return val
-    def GetPosition(self):
-        val = miscc.wxRect_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetSize(self):
-        val = miscc.wxRect_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetLeft(self):
-        val = miscc.wxRect_GetLeft(self.this)
-        return val
-    def GetTop(self):
-        val = miscc.wxRect_GetTop(self.this)
-        return val
-    def GetBottom(self):
-        val = miscc.wxRect_GetBottom(self.this)
-        return val
-    def GetRight(self):
-        val = miscc.wxRect_GetRight(self.this)
-        return val
-    def __setattr__(self,name,value):
-        if name == "x" :
-            miscc.wxRect_x_set(self.this,value)
-            return
-        if name == "y" :
-            miscc.wxRect_y_set(self.this,value)
-            return
-        if name == "width" :
-            miscc.wxRect_width_set(self.this,value)
-            return
-        if name == "height" :
-            miscc.wxRect_height_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "x" : 
-            return miscc.wxRect_x_get(self.this)
-        if name == "y" : 
-            return miscc.wxRect_y_get(self.this)
-        if name == "width" : 
-            return miscc.wxRect_width_get(self.this)
-        if name == "height" : 
-            return miscc.wxRect_height_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxRect instance>"
-class wxRect(wxRectPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxRect,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPyTimerPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxPyTimer(self.this)
-    def Interval(self):
-        val = miscc.wxPyTimer_Interval(self.this)
-        return val
-    def Start(self,*args):
-        val = apply(miscc.wxPyTimer_Start,(self.this,)+args)
-        return val
-    def Stop(self):
-        val = miscc.wxPyTimer_Stop(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPyTimer instance>"
-class wxPyTimer(wxPyTimerPtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxPyTimer(arg0)
-        self.thisown = 1
-
-
-
-
-class wxIndividualLayoutConstraintPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Above(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Above,(self.this,arg0.this,)+args)
-        return val
-    def Absolute(self,arg0):
-        val = miscc.wxIndividualLayoutConstraint_Absolute(self.this,arg0)
-        return val
-    def AsIs(self):
-        val = miscc.wxIndividualLayoutConstraint_AsIs(self.this)
-        return val
-    def Below(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Below,(self.this,arg0.this,)+args)
-        return val
-    def Unconstrained(self):
-        val = miscc.wxIndividualLayoutConstraint_Unconstrained(self.this)
-        return val
-    def LeftOf(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_LeftOf,(self.this,arg0.this,)+args)
-        return val
-    def PercentOf(self,arg0,arg1,arg2):
-        val = miscc.wxIndividualLayoutConstraint_PercentOf(self.this,arg0.this,arg1,arg2)
-        return val
-    def RightOf(self,arg0,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_RightOf,(self.this,arg0.this,)+args)
-        return val
-    def SameAs(self,arg0,arg1,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_SameAs,(self.this,arg0.this,arg1,)+args)
-        return val
-    def Set(self,arg0,arg1,arg2,*args):
-        val = apply(miscc.wxIndividualLayoutConstraint_Set,(self.this,arg0,arg1.this,arg2,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxIndividualLayoutConstraint instance>"
-class wxIndividualLayoutConstraint(wxIndividualLayoutConstraintPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxLayoutConstraintsPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __setattr__(self,name,value):
-        if name == "bottom" :
-            miscc.wxLayoutConstraints_bottom_set(self.this,value.this)
-            return
-        if name == "centreX" :
-            miscc.wxLayoutConstraints_centreX_set(self.this,value.this)
-            return
-        if name == "centreY" :
-            miscc.wxLayoutConstraints_centreY_set(self.this,value.this)
-            return
-        if name == "height" :
-            miscc.wxLayoutConstraints_height_set(self.this,value.this)
-            return
-        if name == "left" :
-            miscc.wxLayoutConstraints_left_set(self.this,value.this)
-            return
-        if name == "right" :
-            miscc.wxLayoutConstraints_right_set(self.this,value.this)
-            return
-        if name == "top" :
-            miscc.wxLayoutConstraints_top_set(self.this,value.this)
-            return
-        if name == "width" :
-            miscc.wxLayoutConstraints_width_set(self.this,value.this)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "bottom" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_bottom_get(self.this))
-        if name == "centreX" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreX_get(self.this))
-        if name == "centreY" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreY_get(self.this))
-        if name == "height" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_height_get(self.this))
-        if name == "left" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_left_get(self.this))
-        if name == "right" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_right_get(self.this))
-        if name == "top" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_top_get(self.this))
-        if name == "width" : 
-            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_width_get(self.this))
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxLayoutConstraints instance>"
-class wxLayoutConstraints(wxLayoutConstraintsPtr):
-    def __init__(self) :
-        self.this = miscc.new_wxLayoutConstraints()
-        self.thisown = 1
-
-
-
-
-class wxRegionPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRegion(self.this)
-    def Clear(self):
-        val = miscc.wxRegion_Clear(self.this)
-        return val
-    def Contains(self,arg0,arg1):
-        val = miscc.wxRegion_Contains(self.this,arg0,arg1)
-        return val
-    def ContainsPoint(self,arg0):
-        val = miscc.wxRegion_ContainsPoint(self.this,arg0.this)
-        return val
-    def ContainsRect(self,arg0):
-        val = miscc.wxRegion_ContainsRect(self.this,arg0.this)
-        return val
-    def GetBox(self):
-        val = miscc.wxRegion_GetBox(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def Intersect(self,arg0):
-        val = miscc.wxRegion_Intersect(self.this,arg0.this)
-        return val
-    def IsEmpty(self):
-        val = miscc.wxRegion_IsEmpty(self.this)
-        return val
-    def Subtract(self,arg0):
-        val = miscc.wxRegion_Subtract(self.this,arg0.this)
-        return val
-    def Union(self,arg0):
-        val = miscc.wxRegion_Union(self.this,arg0.this)
-        return val
-    def Xor(self,arg0):
-        val = miscc.wxRegion_Xor(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxRegion instance>"
-class wxRegion(wxRegionPtr):
-    def __init__(self) :
-        self.this = miscc.new_wxRegion()
-        self.thisown = 1
-
-
-
-
-class wxRegionIteratorPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            miscc.delete_wxRegionIterator(self.this)
-    def GetX(self):
-        val = miscc.wxRegionIterator_GetX(self.this)
-        return val
-    def GetY(self):
-        val = miscc.wxRegionIterator_GetY(self.this)
-        return val
-    def GetW(self):
-        val = miscc.wxRegionIterator_GetW(self.this)
-        return val
-    def GetWidth(self):
-        val = miscc.wxRegionIterator_GetWidth(self.this)
-        return val
-    def GetH(self):
-        val = miscc.wxRegionIterator_GetH(self.this)
-        return val
-    def GetHeight(self):
-        val = miscc.wxRegionIterator_GetHeight(self.this)
-        return val
-    def GetRect(self):
-        val = miscc.wxRegionIterator_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def HaveRects(self):
-        val = miscc.wxRegionIterator_HaveRects(self.this)
-        return val
-    def Reset(self):
-        val = miscc.wxRegionIterator_Reset(self.this)
-        return val
-    def Next(self):
-        val = miscc.wxRegionIterator_Next(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxRegionIterator instance>"
-class wxRegionIterator(wxRegionIteratorPtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxRegionIterator(arg0.this)
-        self.thisown = 1
-
-
-
-
-class wxAcceleratorEntryPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Set(self,arg0,arg1,arg2):
-        val = miscc.wxAcceleratorEntry_Set(self.this,arg0,arg1,arg2)
-        return val
-    def GetFlags(self):
-        val = miscc.wxAcceleratorEntry_GetFlags(self.this)
-        return val
-    def GetKeyCode(self):
-        val = miscc.wxAcceleratorEntry_GetKeyCode(self.this)
-        return val
-    def GetCommand(self):
-        val = miscc.wxAcceleratorEntry_GetCommand(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxAcceleratorEntry instance>"
-class wxAcceleratorEntry(wxAcceleratorEntryPtr):
-    def __init__(self,*args) :
-        self.this = apply(miscc.new_wxAcceleratorEntry,()+args)
-        self.thisown = 1
-
-
-
-
-class wxAcceleratorTablePtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __repr__(self):
-        return "<C wxAcceleratorTable instance>"
-class wxAcceleratorTable(wxAcceleratorTablePtr):
-    def __init__(self,arg0) :
-        self.this = miscc.new_wxAcceleratorTable(arg0.this)
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-def wxFileSelector(arg0,*args):
-    argl = map(None,args)
-    try: argl[5] = argl[5].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxFileSelector,(arg0,)+args)
-    return val
-
-def wxGetTextFromUser(arg0,*args):
-    argl = map(None,args)
-    try: argl[2] = argl[2].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetTextFromUser,(arg0,)+args)
-    return val
-
-def wxGetSingleChoice(arg0,arg1,arg2,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetSingleChoice,(arg0,arg1,arg2,)+args)
-    return val
-
-def wxGetSingleChoiceIndex(arg0,arg1,arg2,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxGetSingleChoiceIndex,(arg0,arg1,arg2,)+args)
-    return val
-
-def wxMessageBox(arg0,*args):
-    argl = map(None,args)
-    try: argl[2] = argl[2].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxMessageBox,(arg0,)+args)
-    return val
-
-wxColourDisplay = miscc.wxColourDisplay
-
-wxDisplayDepth = miscc.wxDisplayDepth
-
-def wxSetCursor(arg0):
-    val = miscc.wxSetCursor(arg0.this)
-    return val
-
-NewId = miscc.NewId
-
-RegisterId = miscc.RegisterId
-
-def wxBeginBusyCursor(*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxBeginBusyCursor,()+args)
-    return val
-
-wxBell = miscc.wxBell
-
-wxDisplaySize = miscc.wxDisplaySize
-
-wxEndBusyCursor = miscc.wxEndBusyCursor
-
-wxExecute = miscc.wxExecute
-
-def wxFindWindowByLabel(arg0,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxFindWindowByLabel,(arg0,)+args)
-    val = wxWindowPtr(val)
-    return val
-
-def wxFindWindowByName(arg0,*args):
-    argl = map(None,args)
-    try: argl[0] = argl[0].this
-    except: pass
-    args = tuple(argl)
-    val = apply(miscc.wxFindWindowByName,(arg0,)+args)
-    val = wxWindowPtr(val)
-    return val
-
-def wxGetActiveWindow():
-    val = miscc.wxGetActiveWindow()
-    val = wxWindowPtr(val)
-    return val
-
-wxGetElapsedTime = miscc.wxGetElapsedTime
-
-wxGetFreeMemory = miscc.wxGetFreeMemory
-
-wxGetMousePosition = miscc.wxGetMousePosition
-
-wxIsBusy = miscc.wxIsBusy
-
-wxNow = miscc.wxNow
-
-wxShell = miscc.wxShell
-
-wxStartTimer = miscc.wxStartTimer
-
-wxGetOsVersion = miscc.wxGetOsVersion
-
-wxYield = miscc.wxYield
-
-wxGetResource = miscc.wxGetResource
-
-wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
-
-wxResourceClear = miscc.wxResourceClear
-
-def wxResourceCreateBitmap(arg0):
-    val = miscc.wxResourceCreateBitmap(arg0)
-    val = wxBitmapPtr(val)
-    val.thisown = 1
-    return val
-
-def wxResourceCreateIcon(arg0):
-    val = miscc.wxResourceCreateIcon(arg0)
-    val = wxIconPtr(val)
-    val.thisown = 1
-    return val
-
-def wxResourceCreateMenuBar(arg0):
-    val = miscc.wxResourceCreateMenuBar(arg0)
-    val = wxMenuBarPtr(val)
-    return val
-
-wxResourceGetIdentifier = miscc.wxResourceGetIdentifier
-
-wxResourceParseData = miscc.wxResourceParseData
-
-wxResourceParseFile = miscc.wxResourceParseFile
-
-wxResourceParseString = miscc.wxResourceParseString
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-wxLeft = miscc.wxLeft
-wxTop = miscc.wxTop
-wxRight = miscc.wxRight
-wxBottom = miscc.wxBottom
-wxWidth = miscc.wxWidth
-wxHeight = miscc.wxHeight
-wxCentre = miscc.wxCentre
-wxCenter = miscc.wxCenter
-wxCentreX = miscc.wxCentreX
-wxCentreY = miscc.wxCentreY
-wxUnconstrained = miscc.wxUnconstrained
-wxAsIs = miscc.wxAsIs
-wxPercentOf = miscc.wxPercentOf
-wxAbove = miscc.wxAbove
-wxBelow = miscc.wxBelow
-wxLeftOf = miscc.wxLeftOf
-wxRightOf = miscc.wxRightOf
-wxSameAs = miscc.wxSameAs
-wxAbsolute = miscc.wxAbsolute
-wxOutRegion = miscc.wxOutRegion
-wxPartRegion = miscc.wxPartRegion
-wxInRegion = miscc.wxInRegion

utils/wxPython/src/msw/stattool.py

@@ -1,281 +0,0 @@
-# This file was created automatically by SWIG.
-import stattoolc
-
-from misc import *
-
-from windows import *
-
-from gdi import *
-
-from controls import *
-
-from events import *
-import wx
-class wxStatusBarPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetFieldRect(self,arg0):
-        val = stattoolc.wxStatusBar_GetFieldRect(self.this,arg0)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def GetFieldsCount(self):
-        val = stattoolc.wxStatusBar_GetFieldsCount(self.this)
-        return val
-    def GetStatusText(self,*args):
-        val = apply(stattoolc.wxStatusBar_GetStatusText,(self.this,)+args)
-        return val
-    def DrawField(self,arg0,arg1):
-        val = stattoolc.wxStatusBar_DrawField(self.this,arg0.this,arg1)
-        return val
-    def DrawFieldText(self,arg0,arg1):
-        val = stattoolc.wxStatusBar_DrawFieldText(self.this,arg0.this,arg1)
-        return val
-    def InitColours(self):
-        val = stattoolc.wxStatusBar_InitColours(self.this)
-        return val
-    def SetFieldsCount(self,*args):
-        val = apply(stattoolc.wxStatusBar_SetFieldsCount,(self.this,)+args)
-        return val
-    def SetStatusText(self,arg0,*args):
-        val = apply(stattoolc.wxStatusBar_SetStatusText,(self.this,arg0,)+args)
-        return val
-    def SetStatusWidths(self,arg0,*args):
-        val = apply(stattoolc.wxStatusBar_SetStatusWidths,(self.this,arg0,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxStatusBar instance>"
-class wxStatusBar(wxStatusBarPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(stattoolc.new_wxStatusBar,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxToolBarToolPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            stattoolc.delete_wxToolBarTool(self.this)
-    def SetSize(self,arg0,arg1):
-        val = stattoolc.wxToolBarTool_SetSize(self.this,arg0,arg1)
-        return val
-    def GetWidth(self):
-        val = stattoolc.wxToolBarTool_GetWidth(self.this)
-        return val
-    def GetHeight(self):
-        val = stattoolc.wxToolBarTool_GetHeight(self.this)
-        return val
-    def __setattr__(self,name,value):
-        if name == "m_toolStyle" :
-            stattoolc.wxToolBarTool_m_toolStyle_set(self.this,value)
-            return
-        if name == "m_clientData" :
-            stattoolc.wxToolBarTool_m_clientData_set(self.this,value)
-            return
-        if name == "m_index" :
-            stattoolc.wxToolBarTool_m_index_set(self.this,value)
-            return
-        if name == "m_x" :
-            stattoolc.wxToolBarTool_m_x_set(self.this,value)
-            return
-        if name == "m_y" :
-            stattoolc.wxToolBarTool_m_y_set(self.this,value)
-            return
-        if name == "m_width" :
-            stattoolc.wxToolBarTool_m_width_set(self.this,value)
-            return
-        if name == "m_height" :
-            stattoolc.wxToolBarTool_m_height_set(self.this,value)
-            return
-        if name == "m_toggleState" :
-            stattoolc.wxToolBarTool_m_toggleState_set(self.this,value)
-            return
-        if name == "m_isToggle" :
-            stattoolc.wxToolBarTool_m_isToggle_set(self.this,value)
-            return
-        if name == "m_deleteSecondBitmap" :
-            stattoolc.wxToolBarTool_m_deleteSecondBitmap_set(self.this,value)
-            return
-        if name == "m_enabled" :
-            stattoolc.wxToolBarTool_m_enabled_set(self.this,value)
-            return
-        if name == "m_bitmap1" :
-            stattoolc.wxToolBarTool_m_bitmap1_set(self.this,value.this)
-            return
-        if name == "m_bitmap2" :
-            stattoolc.wxToolBarTool_m_bitmap2_set(self.this,value.this)
-            return
-        if name == "m_isMenuCommand" :
-            stattoolc.wxToolBarTool_m_isMenuCommand_set(self.this,value)
-            return
-        if name == "m_shortHelpString" :
-            stattoolc.wxToolBarTool_m_shortHelpString_set(self.this,value)
-            return
-        if name == "m_longHelpString" :
-            stattoolc.wxToolBarTool_m_longHelpString_set(self.this,value)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_toolStyle" : 
-            return stattoolc.wxToolBarTool_m_toolStyle_get(self.this)
-        if name == "m_clientData" : 
-            return stattoolc.wxToolBarTool_m_clientData_get(self.this)
-        if name == "m_index" : 
-            return stattoolc.wxToolBarTool_m_index_get(self.this)
-        if name == "m_x" : 
-            return stattoolc.wxToolBarTool_m_x_get(self.this)
-        if name == "m_y" : 
-            return stattoolc.wxToolBarTool_m_y_get(self.this)
-        if name == "m_width" : 
-            return stattoolc.wxToolBarTool_m_width_get(self.this)
-        if name == "m_height" : 
-            return stattoolc.wxToolBarTool_m_height_get(self.this)
-        if name == "m_toggleState" : 
-            return stattoolc.wxToolBarTool_m_toggleState_get(self.this)
-        if name == "m_isToggle" : 
-            return stattoolc.wxToolBarTool_m_isToggle_get(self.this)
-        if name == "m_deleteSecondBitmap" : 
-            return stattoolc.wxToolBarTool_m_deleteSecondBitmap_get(self.this)
-        if name == "m_enabled" : 
-            return stattoolc.wxToolBarTool_m_enabled_get(self.this)
-        if name == "m_bitmap1" : 
-            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap1_get(self.this))
-        if name == "m_bitmap2" : 
-            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap2_get(self.this))
-        if name == "m_isMenuCommand" : 
-            return stattoolc.wxToolBarTool_m_isMenuCommand_get(self.this)
-        if name == "m_shortHelpString" : 
-            return stattoolc.wxToolBarTool_m_shortHelpString_get(self.this)
-        if name == "m_longHelpString" : 
-            return stattoolc.wxToolBarTool_m_longHelpString_get(self.this)
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxToolBarTool instance>"
-class wxToolBarTool(wxToolBarToolPtr):
-    def __init__(self) :
-        self.this = stattoolc.new_wxToolBarTool()
-        self.thisown = 1
-
-
-
-
-class wxToolBarPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def AddSeparator(self):
-        val = stattoolc.wxToolBar_AddSeparator(self.this)
-        return val
-    def AddTool(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(stattoolc.wxToolBar_AddTool,(self.this,arg0,arg1.this,)+args)
-        val = wxToolBarToolPtr(val)
-        return val
-    def AddSimpleTool(self,arg0,arg1,*args):
-        val = apply(stattoolc.wxToolBar_AddSimpleTool,(self.this,arg0,arg1.this,)+args)
-        val = wxToolBarToolPtr(val)
-        return val
-    def EnableTool(self,arg0,arg1):
-        val = stattoolc.wxToolBar_EnableTool(self.this,arg0,arg1)
-        return val
-    def FindToolForPosition(self,arg0,arg1):
-        val = stattoolc.wxToolBar_FindToolForPosition(self.this,arg0,arg1)
-        val = wxToolBarToolPtr(val)
-        return val
-    def GetToolSize(self):
-        val = stattoolc.wxToolBar_GetToolSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetToolBitmapSize(self):
-        val = stattoolc.wxToolBar_GetToolBitmapSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def SetToolBitmapSize(self,arg0):
-        val = stattoolc.wxToolBar_SetToolBitmapSize(self.this,arg0.this)
-        return val
-    def GetMaxSize(self):
-        val = stattoolc.wxToolBar_GetMaxSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetToolEnabled(self,arg0):
-        val = stattoolc.wxToolBar_GetToolEnabled(self.this,arg0)
-        return val
-    def GetToolLongHelp(self,arg0):
-        val = stattoolc.wxToolBar_GetToolLongHelp(self.this,arg0)
-        return val
-    def GetToolPacking(self):
-        val = stattoolc.wxToolBar_GetToolPacking(self.this)
-        return val
-    def GetToolSeparation(self):
-        val = stattoolc.wxToolBar_GetToolSeparation(self.this)
-        return val
-    def GetToolShortHelp(self,arg0):
-        val = stattoolc.wxToolBar_GetToolShortHelp(self.this,arg0)
-        return val
-    def GetToolState(self,arg0):
-        val = stattoolc.wxToolBar_GetToolState(self.this,arg0)
-        return val
-    def Realize(self):
-        val = stattoolc.wxToolBar_Realize(self.this)
-        return val
-    def SetToolLongHelp(self,arg0,arg1):
-        val = stattoolc.wxToolBar_SetToolLongHelp(self.this,arg0,arg1)
-        return val
-    def SetToolShortHelp(self,arg0,arg1):
-        val = stattoolc.wxToolBar_SetToolShortHelp(self.this,arg0,arg1)
-        return val
-    def SetMargins(self,arg0):
-        val = stattoolc.wxToolBar_SetMargins(self.this,arg0.this)
-        return val
-    def SetToolPacking(self,arg0):
-        val = stattoolc.wxToolBar_SetToolPacking(self.this,arg0)
-        return val
-    def SetToolSeparation(self,arg0):
-        val = stattoolc.wxToolBar_SetToolSeparation(self.this,arg0)
-        return val
-    def ToggleTool(self,arg0,arg1):
-        val = stattoolc.wxToolBar_ToggleTool(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxToolBar instance>"
-class wxToolBar(wxToolBarPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(stattoolc.new_wxToolBar,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/utils.py

@@ -1,114 +0,0 @@
-# This file was created automatically by SWIG.
-import utilsc
-class wxConfigPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            utilsc.delete_wxConfig(self.this)
-    def DontCreateOnDemand(self):
-        val = utilsc.wxConfig_DontCreateOnDemand(self.this)
-        return val
-    def DeleteEntry(self,arg0,*args):
-        val = apply(utilsc.wxConfig_DeleteEntry,(self.this,arg0,)+args)
-        return val
-    def DeleteGroup(self,arg0):
-        val = utilsc.wxConfig_DeleteGroup(self.this,arg0)
-        return val
-    def Exists(self,arg0):
-        val = utilsc.wxConfig_Exists(self.this,arg0)
-        return val
-    def Flush(self,*args):
-        val = apply(utilsc.wxConfig_Flush,(self.this,)+args)
-        return val
-    def GetAppName(self):
-        val = utilsc.wxConfig_GetAppName(self.this)
-        return val
-    def GetFirstGroup(self):
-        val = utilsc.wxConfig_GetFirstGroup(self.this)
-        return val
-    def GetFirstEntry(self):
-        val = utilsc.wxConfig_GetFirstEntry(self.this)
-        return val
-    def GetNextGroup(self,arg0):
-        val = utilsc.wxConfig_GetNextGroup(self.this,arg0)
-        return val
-    def GetNextEntry(self,arg0):
-        val = utilsc.wxConfig_GetNextEntry(self.this,arg0)
-        return val
-    def GetNumberOfEntries(self,*args):
-        val = apply(utilsc.wxConfig_GetNumberOfEntries,(self.this,)+args)
-        return val
-    def GetNumberOfGroups(self,*args):
-        val = apply(utilsc.wxConfig_GetNumberOfGroups,(self.this,)+args)
-        return val
-    def GetPath(self):
-        val = utilsc.wxConfig_GetPath(self.this)
-        return val
-    def GetVendorName(self):
-        val = utilsc.wxConfig_GetVendorName(self.this)
-        return val
-    def HasEntry(self,arg0):
-        val = utilsc.wxConfig_HasEntry(self.this,arg0)
-        return val
-    def HasGroup(self,arg0):
-        val = utilsc.wxConfig_HasGroup(self.this,arg0)
-        return val
-    def IsExpandingEnvVars(self):
-        val = utilsc.wxConfig_IsExpandingEnvVars(self.this)
-        return val
-    def IsRecordingDefaults(self):
-        val = utilsc.wxConfig_IsRecordingDefaults(self.this)
-        return val
-    def Read(self,arg0,*args):
-        val = apply(utilsc.wxConfig_Read,(self.this,arg0,)+args)
-        return val
-    def ReadInt(self,arg0,*args):
-        val = apply(utilsc.wxConfig_ReadInt,(self.this,arg0,)+args)
-        return val
-    def ReadFloat(self,arg0,*args):
-        val = apply(utilsc.wxConfig_ReadFloat,(self.this,arg0,)+args)
-        return val
-    def SetAppName(self,arg0):
-        val = utilsc.wxConfig_SetAppName(self.this,arg0)
-        return val
-    def SetExpandEnvVars(self,*args):
-        val = apply(utilsc.wxConfig_SetExpandEnvVars,(self.this,)+args)
-        return val
-    def SetPath(self,arg0):
-        val = utilsc.wxConfig_SetPath(self.this,arg0)
-        return val
-    def SetRecordDefaults(self,*args):
-        val = apply(utilsc.wxConfig_SetRecordDefaults,(self.this,)+args)
-        return val
-    def SetVendorName(self,arg0):
-        val = utilsc.wxConfig_SetVendorName(self.this,arg0)
-        return val
-    def Write(self,arg0,arg1):
-        val = utilsc.wxConfig_Write(self.this,arg0,arg1)
-        return val
-    def WriteInt(self,arg0,arg1):
-        val = utilsc.wxConfig_WriteInt(self.this,arg0,arg1)
-        return val
-    def WriteFloat(self,arg0,arg1):
-        val = utilsc.wxConfig_WriteFloat(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxConfig instance>"
-class wxConfig(wxConfigPtr):
-    def __init__(self,*args) :
-        self.this = apply(utilsc.new_wxConfig,()+args)
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/windows.py

@@ -1,663 +0,0 @@
-# This file was created automatically by SWIG.
-import windowsc
-
-from misc import *
-
-from gdi import *
-import wx
-
-def wxDLG_PNT(win, point):
-    return win.ConvertDialogPointToPixels(point)
-
-def wxDLG_SZE(win, size):
-    return win.ConvertDialogPointToPixels(size)
-
-class wxEvtHandlerPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Connect(self,arg0,arg1,arg2,arg3):
-        val = windowsc.wxEvtHandler_Connect(self.this,arg0,arg1,arg2,arg3)
-        return val
-    def __repr__(self):
-        return "<C wxEvtHandler instance>"
-class wxEvtHandler(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxWindowPtr(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def CaptureMouse(self):
-        val = windowsc.wxWindow_CaptureMouse(self.this)
-        return val
-    def Center(self,*args):
-        val = apply(windowsc.wxWindow_Center,(self.this,)+args)
-        return val
-    def Centre(self,*args):
-        val = apply(windowsc.wxWindow_Centre,(self.this,)+args)
-        return val
-    def ClientToScreen(self,arg0,arg1):
-        val = windowsc.wxWindow_ClientToScreen(self.this,arg0,arg1)
-        return val
-    def Close(self,*args):
-        val = apply(windowsc.wxWindow_Close,(self.this,)+args)
-        return val
-    def Destroy(self):
-        val = windowsc.wxWindow_Destroy(self.this)
-        return val
-    def DestroyChildren(self):
-        val = windowsc.wxWindow_DestroyChildren(self.this)
-        return val
-    def DragAcceptFiles(self,arg0):
-        val = windowsc.wxWindow_DragAcceptFiles(self.this,arg0)
-        return val
-    def Enable(self,arg0):
-        val = windowsc.wxWindow_Enable(self.this,arg0)
-        return val
-    def FindWindowByID(self,arg0):
-        val = windowsc.wxWindow_FindWindowByID(self.this,arg0)
-        val = wxWindowPtr(val)
-        return val
-    def FindWindowByName(self,arg0):
-        val = windowsc.wxWindow_FindWindowByName(self.this,arg0)
-        val = wxWindowPtr(val)
-        return val
-    def Fit(self):
-        val = windowsc.wxWindow_Fit(self.this)
-        return val
-    def GetBackgroundColour(self):
-        val = windowsc.wxWindow_GetBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def GetCharHeight(self):
-        val = windowsc.wxWindow_GetCharHeight(self.this)
-        return val
-    def GetCharWidth(self):
-        val = windowsc.wxWindow_GetCharWidth(self.this)
-        return val
-    def GetClientSizeTuple(self):
-        val = windowsc.wxWindow_GetClientSizeTuple(self.this)
-        return val
-    def GetClientSize(self):
-        val = windowsc.wxWindow_GetClientSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetConstraints(self):
-        val = windowsc.wxWindow_GetConstraints(self.this)
-        val = wxLayoutConstraintsPtr(val)
-        return val
-    def GetDefaultItem(self):
-        val = windowsc.wxWindow_GetDefaultItem(self.this)
-        val = wxButtonPtr(val)
-        return val
-    def GetFont(self):
-        val = windowsc.wxWindow_GetFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetForegroundColour(self):
-        val = windowsc.wxWindow_GetForegroundColour(self.this)
-        val = wxColourPtr(val)
-        val.thisown = 1
-        return val
-    def GetGrandParent(self):
-        val = windowsc.wxWindow_GetGrandParent(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def GetId(self):
-        val = windowsc.wxWindow_GetId(self.this)
-        return val
-    def GetLabel(self):
-        val = windowsc.wxWindow_GetLabel(self.this)
-        return val
-    def GetName(self):
-        val = windowsc.wxWindow_GetName(self.this)
-        return val
-    def GetParent(self):
-        val = windowsc.wxWindow_GetParent(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def GetPositionTuple(self):
-        val = windowsc.wxWindow_GetPositionTuple(self.this)
-        return val
-    def GetPosition(self):
-        val = windowsc.wxWindow_GetPosition(self.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def GetRect(self):
-        val = windowsc.wxWindow_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def GetReturnCode(self):
-        val = windowsc.wxWindow_GetReturnCode(self.this)
-        return val
-    def GetScrollThumb(self,arg0):
-        val = windowsc.wxWindow_GetScrollThumb(self.this,arg0)
-        return val
-    def GetScrollPos(self,arg0):
-        val = windowsc.wxWindow_GetScrollPos(self.this,arg0)
-        return val
-    def GetScrollRange(self,arg0):
-        val = windowsc.wxWindow_GetScrollRange(self.this,arg0)
-        return val
-    def GetSizeTuple(self):
-        val = windowsc.wxWindow_GetSizeTuple(self.this)
-        return val
-    def GetSize(self):
-        val = windowsc.wxWindow_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def GetTextExtent(self,arg0):
-        val = windowsc.wxWindow_GetTextExtent(self.this,arg0)
-        return val
-    def GetTitle(self):
-        val = windowsc.wxWindow_GetTitle(self.this)
-        return val
-    def GetWindowStyleFlag(self):
-        val = windowsc.wxWindow_GetWindowStyleFlag(self.this)
-        return val
-    def InitDialog(self):
-        val = windowsc.wxWindow_InitDialog(self.this)
-        return val
-    def IsEnabled(self):
-        val = windowsc.wxWindow_IsEnabled(self.this)
-        return val
-    def IsRetained(self):
-        val = windowsc.wxWindow_IsRetained(self.this)
-        return val
-    def IsShown(self):
-        val = windowsc.wxWindow_IsShown(self.this)
-        return val
-    def Layout(self):
-        val = windowsc.wxWindow_Layout(self.this)
-        return val
-    def LoadFromResource(self,arg0,arg1,*args):
-        val = apply(windowsc.wxWindow_LoadFromResource,(self.this,arg0.this,arg1,)+args)
-        return val
-    def Lower(self):
-        val = windowsc.wxWindow_Lower(self.this)
-        return val
-    def MakeModal(self,arg0):
-        val = windowsc.wxWindow_MakeModal(self.this,arg0)
-        return val
-    def Move(self,arg0,arg1):
-        val = windowsc.wxWindow_Move(self.this,arg0,arg1)
-        return val
-    def PopupMenu(self,arg0,arg1,arg2):
-        val = windowsc.wxWindow_PopupMenu(self.this,arg0.this,arg1,arg2)
-        return val
-    def Raise(self):
-        val = windowsc.wxWindow_Raise(self.this)
-        return val
-    def Refresh(self,*args):
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windowsc.wxWindow_Refresh,(self.this,)+args)
-        return val
-    def ReleaseMouse(self):
-        val = windowsc.wxWindow_ReleaseMouse(self.this)
-        return val
-    def ScreenToClient(self,arg0,arg1):
-        val = windowsc.wxWindow_ScreenToClient(self.this,arg0,arg1)
-        return val
-    def ScrollWindow(self,arg0,arg1,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windowsc.wxWindow_ScrollWindow,(self.this,arg0,arg1,)+args)
-        return val
-    def SetAcceleratorTable(self,arg0):
-        val = windowsc.wxWindow_SetAcceleratorTable(self.this,arg0.this)
-        return val
-    def SetAutoLayout(self,arg0):
-        val = windowsc.wxWindow_SetAutoLayout(self.this,arg0)
-        return val
-    def SetBackgroundColour(self,arg0):
-        val = windowsc.wxWindow_SetBackgroundColour(self.this,arg0.this)
-        return val
-    def SetConstraints(self,arg0):
-        val = windowsc.wxWindow_SetConstraints(self.this,arg0.this)
-        return val
-    def SetDoubleClick(self,arg0):
-        val = windowsc.wxWindow_SetDoubleClick(self.this,arg0)
-        return val
-    def SetFocus(self):
-        val = windowsc.wxWindow_SetFocus(self.this)
-        return val
-    def SetFont(self,arg0):
-        val = windowsc.wxWindow_SetFont(self.this,arg0.this)
-        return val
-    def SetForegroundColour(self,arg0):
-        val = windowsc.wxWindow_SetForegroundColour(self.this,arg0.this)
-        return val
-    def SetId(self,arg0):
-        val = windowsc.wxWindow_SetId(self.this,arg0)
-        return val
-    def SetName(self,arg0):
-        val = windowsc.wxWindow_SetName(self.this,arg0)
-        return val
-    def SetReturnCode(self,arg0):
-        val = windowsc.wxWindow_SetReturnCode(self.this,arg0)
-        return val
-    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(windowsc.wxWindow_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def SetScrollPos(self,arg0,arg1,*args):
-        val = apply(windowsc.wxWindow_SetScrollPos,(self.this,arg0,arg1,)+args)
-        return val
-    def SetDimensions(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(windowsc.wxWindow_SetDimensions,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def SetSize(self,arg0):
-        val = windowsc.wxWindow_SetSize(self.this,arg0.this)
-        return val
-    def SetPosition(self,arg0):
-        val = windowsc.wxWindow_SetPosition(self.this,arg0.this)
-        return val
-    def SetSizeHints(self,*args):
-        val = apply(windowsc.wxWindow_SetSizeHints,(self.this,)+args)
-        return val
-    def SetClientSize(self,arg0,arg1):
-        val = windowsc.wxWindow_SetClientSize(self.this,arg0,arg1)
-        return val
-    def SetCursor(self,arg0):
-        val = windowsc.wxWindow_SetCursor(self.this,arg0.this)
-        return val
-    def SetTitle(self,arg0):
-        val = windowsc.wxWindow_SetTitle(self.this,arg0)
-        return val
-    def Show(self,arg0):
-        val = windowsc.wxWindow_Show(self.this,arg0)
-        return val
-    def TransferDataFromWindow(self):
-        val = windowsc.wxWindow_TransferDataFromWindow(self.this)
-        return val
-    def TransferDataToWindow(self):
-        val = windowsc.wxWindow_TransferDataToWindow(self.this)
-        return val
-    def Validate(self):
-        val = windowsc.wxWindow_Validate(self.this)
-        return val
-    def WarpPointer(self,arg0,arg1):
-        val = windowsc.wxWindow_WarpPointer(self.this,arg0,arg1)
-        return val
-    def ConvertDialogPointToPixels(self,arg0):
-        val = windowsc.wxWindow_ConvertDialogPointToPixels(self.this,arg0.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def ConvertDialogSizeToPixels(self,arg0):
-        val = windowsc.wxWindow_ConvertDialogSizeToPixels(self.this,arg0.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def ConvertPixelPointToDialog(self,arg0):
-        val = windowsc.wxWindow_ConvertPixelPointToDialog(self.this,arg0.this)
-        val = wxPointPtr(val)
-        val.thisown = 1
-        return val
-    def ConvertPixelSizeToDialog(self,arg0):
-        val = windowsc.wxWindow_ConvertPixelSizeToDialog(self.this,arg0.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxWindow instance>"
-class wxWindow(wxWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxPanelPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def InitDialog(self):
-        val = windowsc.wxPanel_InitDialog(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxPanel instance>"
-class wxPanel(wxPanelPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxPanel,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxDialogPtr(wxPanelPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Centre(self,*args):
-        val = apply(windowsc.wxDialog_Centre,(self.this,)+args)
-        return val
-    def EndModal(self,arg0):
-        val = windowsc.wxDialog_EndModal(self.this,arg0)
-        return val
-    def GetTitle(self):
-        val = windowsc.wxDialog_GetTitle(self.this)
-        return val
-    def Iconize(self,arg0):
-        val = windowsc.wxDialog_Iconize(self.this,arg0)
-        return val
-    def IsIconized(self):
-        val = windowsc.wxDialog_IsIconized(self.this)
-        return val
-    def SetModal(self,arg0):
-        val = windowsc.wxDialog_SetModal(self.this,arg0)
-        return val
-    def IsModal(self):
-        val = windowsc.wxDialog_IsModal(self.this)
-        return val
-    def SetTitle(self,arg0):
-        val = windowsc.wxDialog_SetTitle(self.this,arg0)
-        return val
-    def Show(self,arg0):
-        val = windowsc.wxDialog_Show(self.this,arg0)
-        return val
-    def ShowModal(self):
-        val = windowsc.wxDialog_ShowModal(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxDialog instance>"
-class wxDialog(wxDialogPtr):
-    def __init__(self,arg0,arg1,arg2,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxDialog,(arg0.this,arg1,arg2,)+args)
-        self.thisown = 1
-        wx._StdDialogCallbacks(self)
-
-
-
-
-class wxScrolledWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def EnableScrolling(self,arg0,arg1):
-        val = windowsc.wxScrolledWindow_EnableScrolling(self.this,arg0,arg1)
-        return val
-    def GetScrollPixelsPerUnit(self):
-        val = windowsc.wxScrolledWindow_GetScrollPixelsPerUnit(self.this)
-        return val
-    def GetVirtualSize(self):
-        val = windowsc.wxScrolledWindow_GetVirtualSize(self.this)
-        return val
-    def IsRetained(self):
-        val = windowsc.wxScrolledWindow_IsRetained(self.this)
-        return val
-    def PrepareDC(self,arg0):
-        val = windowsc.wxScrolledWindow_PrepareDC(self.this,arg0.this)
-        return val
-    def Scroll(self,arg0,arg1):
-        val = windowsc.wxScrolledWindow_Scroll(self.this,arg0,arg1)
-        return val
-    def SetScrollbars(self,arg0,arg1,arg2,arg3,*args):
-        val = apply(windowsc.wxScrolledWindow_SetScrollbars,(self.this,arg0,arg1,arg2,arg3,)+args)
-        return val
-    def ViewStart(self):
-        val = windowsc.wxScrolledWindow_ViewStart(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxScrolledWindow instance>"
-class wxScrolledWindow(wxScrolledWindowPtr):
-    def __init__(self,arg0,*args) :
-        argl = map(None,args)
-        try: argl[1] = argl[1].this
-        except: pass
-        try: argl[2] = argl[2].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windowsc.new_wxScrolledWindow,(arg0.this,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._StdOnScrollCallbacks(self)
-
-
-
-
-class wxMenuPtr(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0,arg1,*args):
-        val = apply(windowsc.wxMenu_Append,(self.this,arg0,arg1,)+args)
-        return val
-    def AppendMenu(self,arg0,arg1,arg2,*args):
-        val = apply(windowsc.wxMenu_AppendMenu,(self.this,arg0,arg1,arg2.this,)+args)
-        return val
-    def AppendSeparator(self):
-        val = windowsc.wxMenu_AppendSeparator(self.this)
-        return val
-    def Break(self):
-        val = windowsc.wxMenu_Break(self.this)
-        return val
-    def Check(self,arg0,arg1):
-        val = windowsc.wxMenu_Check(self.this,arg0,arg1)
-        return val
-    def Enable(self,arg0,arg1):
-        val = windowsc.wxMenu_Enable(self.this,arg0,arg1)
-        return val
-    def FindItem(self,arg0):
-        val = windowsc.wxMenu_FindItem(self.this,arg0)
-        return val
-    def GetTitle(self):
-        val = windowsc.wxMenu_GetTitle(self.this)
-        return val
-    def SetTitle(self,arg0):
-        val = windowsc.wxMenu_SetTitle(self.this,arg0)
-        return val
-    def FindItemForId(self,arg0):
-        val = windowsc.wxMenu_FindItemForId(self.this,arg0)
-        val = wxMenuItemPtr(val)
-        return val
-    def GetHelpString(self,arg0):
-        val = windowsc.wxMenu_GetHelpString(self.this,arg0)
-        return val
-    def GetLabel(self,arg0):
-        val = windowsc.wxMenu_GetLabel(self.this,arg0)
-        return val
-    def SetHelpString(self,arg0,arg1):
-        val = windowsc.wxMenu_SetHelpString(self.this,arg0,arg1)
-        return val
-    def IsChecked(self,arg0):
-        val = windowsc.wxMenu_IsChecked(self.this,arg0)
-        return val
-    def IsEnabled(self,arg0):
-        val = windowsc.wxMenu_IsEnabled(self.this,arg0)
-        return val
-    def SetLabel(self,arg0,arg1):
-        val = windowsc.wxMenu_SetLabel(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxMenu instance>"
-class wxMenu(wxMenuPtr):
-    def __init__(self,*args) :
-        self.this = apply(windowsc.new_wxMenu,()+args)
-        self.thisown = 1
-
-
-
-
-class wxPyMenuPtr(wxMenuPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            windowsc.delete_wxPyMenu(self.this)
-    def __repr__(self):
-        return "<C wxPyMenu instance>"
-class wxPyMenu(wxPyMenuPtr):
-    def __init__(self,*args) :
-        self.this = apply(windowsc.new_wxPyMenu,()+args)
-        self.thisown = 1
-
-
-
-
-class wxMenuBarPtr(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def Append(self,arg0,arg1):
-        val = windowsc.wxMenuBar_Append(self.this,arg0.this,arg1)
-        return val
-    def Check(self,arg0,arg1):
-        val = windowsc.wxMenuBar_Check(self.this,arg0,arg1)
-        return val
-    def Checked(self,arg0):
-        val = windowsc.wxMenuBar_Checked(self.this,arg0)
-        return val
-    def Enable(self,arg0,arg1):
-        val = windowsc.wxMenuBar_Enable(self.this,arg0,arg1)
-        return val
-    def Enabled(self,arg0):
-        val = windowsc.wxMenuBar_Enabled(self.this,arg0)
-        return val
-    def FindMenuItem(self,arg0,arg1):
-        val = windowsc.wxMenuBar_FindMenuItem(self.this,arg0,arg1)
-        return val
-    def FindItemForId(self,arg0):
-        val = windowsc.wxMenuBar_FindItemForId(self.this,arg0)
-        val = wxMenuItemPtr(val)
-        return val
-    def EnableTop(self,arg0,arg1):
-        val = windowsc.wxMenuBar_EnableTop(self.this,arg0,arg1)
-        return val
-    def GetHelpString(self,arg0):
-        val = windowsc.wxMenuBar_GetHelpString(self.this,arg0)
-        return val
-    def GetLabel(self,arg0):
-        val = windowsc.wxMenuBar_GetLabel(self.this,arg0)
-        return val
-    def SetHelpString(self,arg0,arg1):
-        val = windowsc.wxMenuBar_SetHelpString(self.this,arg0,arg1)
-        return val
-    def SetLabel(self,arg0,arg1):
-        val = windowsc.wxMenuBar_SetLabel(self.this,arg0,arg1)
-        return val
-    def GetLabelTop(self,arg0):
-        val = windowsc.wxMenuBar_GetLabelTop(self.this,arg0)
-        return val
-    def SetLabelTop(self,arg0,arg1):
-        val = windowsc.wxMenuBar_SetLabelTop(self.this,arg0,arg1)
-        return val
-    def GetMenuCount(self):
-        val = windowsc.wxMenuBar_GetMenuCount(self.this)
-        return val
-    def GetMenu(self,arg0):
-        val = windowsc.wxMenuBar_GetMenu(self.this,arg0)
-        val = wxMenuPtr(val)
-        return val
-    def __repr__(self):
-        return "<C wxMenuBar instance>"
-class wxMenuBar(wxMenuBarPtr):
-    def __init__(self) :
-        self.this = windowsc.new_wxMenuBar()
-        self.thisown = 1
-
-
-
-
-class wxMenuItemPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def IsSeparator(self):
-        val = windowsc.wxMenuItem_IsSeparator(self.this)
-        return val
-    def IsEnabled(self):
-        val = windowsc.wxMenuItem_IsEnabled(self.this)
-        return val
-    def IsChecked(self):
-        val = windowsc.wxMenuItem_IsChecked(self.this)
-        return val
-    def IsCheckable(self):
-        val = windowsc.wxMenuItem_IsCheckable(self.this)
-        return val
-    def GetId(self):
-        val = windowsc.wxMenuItem_GetId(self.this)
-        return val
-    def GetSubMenu(self):
-        val = windowsc.wxMenuItem_GetSubMenu(self.this)
-        val = wxMenuPtr(val)
-        return val
-    def SetName(self,arg0):
-        val = windowsc.wxMenuItem_SetName(self.this,arg0)
-        return val
-    def GetName(self):
-        val = windowsc.wxMenuItem_GetName(self.this)
-        return val
-    def GetHelp(self):
-        val = windowsc.wxMenuItem_GetHelp(self.this)
-        return val
-    def SetHelp(self,arg0):
-        val = windowsc.wxMenuItem_SetHelp(self.this,arg0)
-        return val
-    def Enable(self,*args):
-        val = apply(windowsc.wxMenuItem_Enable,(self.this,)+args)
-        return val
-    def Check(self,*args):
-        val = apply(windowsc.wxMenuItem_Check,(self.this,)+args)
-        return val
-    def DeleteSubMenu(self):
-        val = windowsc.wxMenuItem_DeleteSubMenu(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxMenuItem instance>"
-class wxMenuItem(wxMenuItemPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-def wxWindow_FindFocus():
-    val = windowsc.wxWindow_FindFocus()
-    val = wxWindowPtr(val)
-    return val
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

utils/wxPython/src/msw/windows2.py

@@ -1,588 +0,0 @@
-# This file was created automatically by SWIG.
-import windows2c
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-
-from controls import *
-
-from events import *
-import wx
-class wxGridCellPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            windows2c.delete_wxGridCell(self.this)
-    def GetTextValue(self):
-        val = windows2c.wxGridCell_GetTextValue(self.this)
-        return val
-    def SetTextValue(self,arg0):
-        val = windows2c.wxGridCell_SetTextValue(self.this,arg0)
-        return val
-    def GetFont(self):
-        val = windows2c.wxGridCell_GetFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def SetFont(self,arg0):
-        val = windows2c.wxGridCell_SetFont(self.this,arg0.this)
-        return val
-    def GetTextColour(self):
-        val = windows2c.wxGridCell_GetTextColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def SetTextColour(self,arg0):
-        val = windows2c.wxGridCell_SetTextColour(self.this,arg0.this)
-        return val
-    def GetBackgroundColour(self):
-        val = windows2c.wxGridCell_GetBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def SetBackgroundColour(self,arg0):
-        val = windows2c.wxGridCell_SetBackgroundColour(self.this,arg0.this)
-        return val
-    def GetBackgroundBrush(self):
-        val = windows2c.wxGridCell_GetBackgroundBrush(self.this)
-        val = wxBrushPtr(val)
-        return val
-    def GetAlignment(self):
-        val = windows2c.wxGridCell_GetAlignment(self.this)
-        return val
-    def SetAlignment(self,arg0):
-        val = windows2c.wxGridCell_SetAlignment(self.this,arg0)
-        return val
-    def GetCellBitmap(self):
-        val = windows2c.wxGridCell_GetCellBitmap(self.this)
-        val = wxBitmapPtr(val)
-        return val
-    def SetCellBitmap(self,arg0):
-        val = windows2c.wxGridCell_SetCellBitmap(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxGridCell instance>"
-class wxGridCell(wxGridCellPtr):
-    def __init__(self) :
-        self.this = windows2c.new_wxGridCell()
-        self.thisown = 1
-
-
-
-
-class wxGridPtr(wxPanelPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def AdjustScrollbars(self):
-        val = windows2c.wxGrid_AdjustScrollbars(self.this)
-        return val
-    def AppendCols(self,*args):
-        val = apply(windows2c.wxGrid_AppendCols,(self.this,)+args)
-        return val
-    def AppendRows(self,*args):
-        val = apply(windows2c.wxGrid_AppendRows,(self.this,)+args)
-        return val
-    def BeginBatch(self):
-        val = windows2c.wxGrid_BeginBatch(self.this)
-        return val
-    def CellHitTest(self,arg0,arg1):
-        val = windows2c.wxGrid_CellHitTest(self.this,arg0,arg1)
-        return val
-    def CreateGrid(self,arg0,arg1,*args):
-        val = apply(windows2c.wxGrid_CreateGrid,(self.this,arg0,arg1,)+args)
-        return val
-    def CurrentCellVisible(self):
-        val = windows2c.wxGrid_CurrentCellVisible(self.this)
-        return val
-    def DeleteCols(self,*args):
-        val = apply(windows2c.wxGrid_DeleteCols,(self.this,)+args)
-        return val
-    def DeleteRows(self,*args):
-        val = apply(windows2c.wxGrid_DeleteRows,(self.this,)+args)
-        return val
-    def EndBatch(self):
-        val = windows2c.wxGrid_EndBatch(self.this)
-        return val
-    def GetBatchCount(self):
-        val = windows2c.wxGrid_GetBatchCount(self.this)
-        return val
-    def GetCell(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCell(self.this,arg0,arg1)
-        val = wxGridCellPtr(val)
-        return val
-    def GetCellAlignment(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellAlignment(self.this,arg0,arg1)
-        return val
-    def GetDefCellAlignment(self):
-        val = windows2c.wxGrid_GetDefCellAlignment(self.this)
-        return val
-    def GetCellBackgroundColour(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellBackgroundColour(self.this,arg0,arg1)
-        val = wxColourPtr(val)
-        return val
-    def GetDefCellBackgroundColour(self):
-        val = windows2c.wxGrid_GetDefCellBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetCellTextColour(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellTextColour(self.this,arg0,arg1)
-        val = wxColourPtr(val)
-        return val
-    def GetDefCellTextColour(self):
-        val = windows2c.wxGrid_GetDefCellTextColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetCellTextFont(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellTextFont(self.this,arg0,arg1)
-        val = wxFontPtr(val)
-        return val
-    def GetDefCellTextFont(self):
-        val = windows2c.wxGrid_GetDefCellTextFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetCellValue(self,arg0,arg1):
-        val = windows2c.wxGrid_GetCellValue(self.this,arg0,arg1)
-        return val
-    def GetCols(self):
-        val = windows2c.wxGrid_GetCols(self.this)
-        return val
-    def GetColumnWidth(self,arg0):
-        val = windows2c.wxGrid_GetColumnWidth(self.this,arg0)
-        return val
-    def GetCurrentRect(self):
-        val = windows2c.wxGrid_GetCurrentRect(self.this)
-        val = wxRectPtr(val)
-        return val
-    def GetCursorColumn(self):
-        val = windows2c.wxGrid_GetCursorColumn(self.this)
-        return val
-    def GetCursorRow(self):
-        val = windows2c.wxGrid_GetCursorRow(self.this)
-        return val
-    def GetEditable(self):
-        val = windows2c.wxGrid_GetEditable(self.this)
-        return val
-    def GetHorizScrollBar(self):
-        val = windows2c.wxGrid_GetHorizScrollBar(self.this)
-        val = wxScrollBarPtr(val)
-        return val
-    def GetLabelAlignment(self,arg0):
-        val = windows2c.wxGrid_GetLabelAlignment(self.this,arg0)
-        return val
-    def GetLabelBackgroundColour(self):
-        val = windows2c.wxGrid_GetLabelBackgroundColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetLabelSize(self,arg0):
-        val = windows2c.wxGrid_GetLabelSize(self.this,arg0)
-        return val
-    def GetLabelTextColour(self):
-        val = windows2c.wxGrid_GetLabelTextColour(self.this)
-        val = wxColourPtr(val)
-        return val
-    def GetLabelTextFont(self):
-        val = windows2c.wxGrid_GetLabelTextFont(self.this)
-        val = wxFontPtr(val)
-        return val
-    def GetLabelValue(self,arg0,arg1):
-        val = windows2c.wxGrid_GetLabelValue(self.this,arg0,arg1)
-        return val
-    def GetRowHeight(self,arg0):
-        val = windows2c.wxGrid_GetRowHeight(self.this,arg0)
-        return val
-    def GetRows(self):
-        val = windows2c.wxGrid_GetRows(self.this)
-        return val
-    def GetScrollPosX(self):
-        val = windows2c.wxGrid_GetScrollPosX(self.this)
-        return val
-    def GetScrollPosY(self):
-        val = windows2c.wxGrid_GetScrollPosY(self.this)
-        return val
-    def GetTextItem(self):
-        val = windows2c.wxGrid_GetTextItem(self.this)
-        val = wxTextCtrlPtr(val)
-        return val
-    def GetVertScrollBar(self):
-        val = windows2c.wxGrid_GetVertScrollBar(self.this)
-        val = wxScrollBarPtr(val)
-        return val
-    def InsertCols(self,*args):
-        val = apply(windows2c.wxGrid_InsertCols,(self.this,)+args)
-        return val
-    def InsertRows(self,*args):
-        val = apply(windows2c.wxGrid_InsertRows,(self.this,)+args)
-        return val
-    def OnActivate(self,arg0):
-        val = windows2c.wxGrid_OnActivate(self.this,arg0)
-        return val
-    def SetCellAlignment(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellAlignment(self.this,arg0,arg1,arg2)
-        return val
-    def SetDefCellAlignment(self,arg0):
-        val = windows2c.wxGrid_SetDefCellAlignment(self.this,arg0)
-        return val
-    def SetCellBackgroundColour(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellBackgroundColour(self.this,arg0.this,arg1,arg2)
-        return val
-    def SetDefCellBackgroundColour(self,arg0):
-        val = windows2c.wxGrid_SetDefCellBackgroundColour(self.this,arg0.this)
-        return val
-    def SetCellTextColour(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellTextColour(self.this,arg0.this,arg1,arg2)
-        return val
-    def SetDefCellTextColour(self,arg0):
-        val = windows2c.wxGrid_SetDefCellTextColour(self.this,arg0.this)
-        return val
-    def SetCellTextFont(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellTextFont(self.this,arg0.this,arg1,arg2)
-        return val
-    def SetDefCellTextFont(self,arg0):
-        val = windows2c.wxGrid_SetDefCellTextFont(self.this,arg0.this)
-        return val
-    def SetCellValue(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetCellValue(self.this,arg0,arg1,arg2)
-        return val
-    def SetColumnWidth(self,arg0,arg1):
-        val = windows2c.wxGrid_SetColumnWidth(self.this,arg0,arg1)
-        return val
-    def SetDividerPen(self,arg0):
-        val = windows2c.wxGrid_SetDividerPen(self.this,arg0.this)
-        return val
-    def SetEditable(self,arg0):
-        val = windows2c.wxGrid_SetEditable(self.this,arg0)
-        return val
-    def SetGridCursor(self,arg0,arg1):
-        val = windows2c.wxGrid_SetGridCursor(self.this,arg0,arg1)
-        return val
-    def SetLabelAlignment(self,arg0,arg1):
-        val = windows2c.wxGrid_SetLabelAlignment(self.this,arg0,arg1)
-        return val
-    def SetLabelBackgroundColour(self,arg0):
-        val = windows2c.wxGrid_SetLabelBackgroundColour(self.this,arg0.this)
-        return val
-    def SetLabelSize(self,arg0,arg1):
-        val = windows2c.wxGrid_SetLabelSize(self.this,arg0,arg1)
-        return val
-    def SetLabelTextColour(self,arg0):
-        val = windows2c.wxGrid_SetLabelTextColour(self.this,arg0.this)
-        return val
-    def SetLabelTextFont(self,arg0):
-        val = windows2c.wxGrid_SetLabelTextFont(self.this,arg0.this)
-        return val
-    def SetLabelValue(self,arg0,arg1,arg2):
-        val = windows2c.wxGrid_SetLabelValue(self.this,arg0,arg1,arg2)
-        return val
-    def SetRowHeight(self,arg0,arg1):
-        val = windows2c.wxGrid_SetRowHeight(self.this,arg0,arg1)
-        return val
-    def UpdateDimensions(self):
-        val = windows2c.wxGrid_UpdateDimensions(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxGrid instance>"
-class wxGrid(wxGridPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxGrid,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._checkForCallback(self, 'OnSelectCell',           wxEVT_GRID_SELECT_CELL)
-        wx._checkForCallback(self, 'OnCreateCell',           wxEVT_GRID_CREATE_CELL)
-        wx._checkForCallback(self, 'OnChangeLabels',         wxEVT_GRID_CHANGE_LABELS)
-        wx._checkForCallback(self, 'OnChangeSelectionLabel', wxEVT_GRID_CHANGE_SEL_LABEL)
-        wx._checkForCallback(self, 'OnCellChange',           wxEVT_GRID_CELL_CHANGE)
-        wx._checkForCallback(self, 'OnCellLeftClick',        wxEVT_GRID_CELL_LCLICK)
-        wx._checkForCallback(self, 'OnCellRightClick',       wxEVT_GRID_CELL_RCLICK)
-        wx._checkForCallback(self, 'OnLabelLeftClick',       wxEVT_GRID_LABEL_LCLICK)
-        wx._checkForCallback(self, 'OnLabelRightClick',      wxEVT_GRID_LABEL_RCLICK)
-
-
-
-
-class wxGridEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __setattr__(self,name,value):
-        if name == "m_row" :
-            windows2c.wxGridEvent_m_row_set(self.this,value)
-            return
-        if name == "m_col" :
-            windows2c.wxGridEvent_m_col_set(self.this,value)
-            return
-        if name == "m_x" :
-            windows2c.wxGridEvent_m_x_set(self.this,value)
-            return
-        if name == "m_y" :
-            windows2c.wxGridEvent_m_y_set(self.this,value)
-            return
-        if name == "m_control" :
-            windows2c.wxGridEvent_m_control_set(self.this,value)
-            return
-        if name == "m_shift" :
-            windows2c.wxGridEvent_m_shift_set(self.this,value)
-            return
-        if name == "m_cell" :
-            windows2c.wxGridEvent_m_cell_set(self.this,value.this)
-            return
-        self.__dict__[name] = value
-    def __getattr__(self,name):
-        if name == "m_row" : 
-            return windows2c.wxGridEvent_m_row_get(self.this)
-        if name == "m_col" : 
-            return windows2c.wxGridEvent_m_col_get(self.this)
-        if name == "m_x" : 
-            return windows2c.wxGridEvent_m_x_get(self.this)
-        if name == "m_y" : 
-            return windows2c.wxGridEvent_m_y_get(self.this)
-        if name == "m_control" : 
-            return windows2c.wxGridEvent_m_control_get(self.this)
-        if name == "m_shift" : 
-            return windows2c.wxGridEvent_m_shift_get(self.this)
-        if name == "m_cell" : 
-            return wxGridCellPtr(windows2c.wxGridEvent_m_cell_get(self.this))
-        raise AttributeError,name
-    def __repr__(self):
-        return "<C wxGridEvent instance>"
-class wxGridEvent(wxGridEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxNotebookEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSelection(self):
-        val = windows2c.wxNotebookEvent_GetSelection(self.this)
-        return val
-    def GetOldSelection(self):
-        val = windows2c.wxNotebookEvent_GetOldSelection(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxNotebookEvent instance>"
-class wxNotebookEvent(wxNotebookEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxNotebookPtr(wxControlPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetPageCount(self):
-        val = windows2c.wxNotebook_GetPageCount(self.this)
-        return val
-    def SetSelection(self,arg0):
-        val = windows2c.wxNotebook_SetSelection(self.this,arg0)
-        return val
-    def AdvanceSelection(self,*args):
-        val = apply(windows2c.wxNotebook_AdvanceSelection,(self.this,)+args)
-        return val
-    def GetSelection(self):
-        val = windows2c.wxNotebook_GetSelection(self.this)
-        return val
-    def SetPageText(self,arg0,arg1):
-        val = windows2c.wxNotebook_SetPageText(self.this,arg0,arg1)
-        return val
-    def GetPageText(self,arg0):
-        val = windows2c.wxNotebook_GetPageText(self.this,arg0)
-        return val
-    def SetImageList(self,arg0):
-        val = windows2c.wxNotebook_SetImageList(self.this,arg0)
-        return val
-    def GetImageList(self):
-        val = windows2c.wxNotebook_GetImageList(self.this)
-        return val
-    def GetPageImage(self,arg0):
-        val = windows2c.wxNotebook_GetPageImage(self.this,arg0)
-        return val
-    def SetPageImage(self,arg0,arg1):
-        val = windows2c.wxNotebook_SetPageImage(self.this,arg0,arg1)
-        return val
-    def GetRowCount(self):
-        val = windows2c.wxNotebook_GetRowCount(self.this)
-        return val
-    def DeletePage(self,arg0):
-        val = windows2c.wxNotebook_DeletePage(self.this,arg0)
-        return val
-    def DeleteAllPages(self):
-        val = windows2c.wxNotebook_DeleteAllPages(self.this)
-        return val
-    def AddPage(self,arg0,arg1,*args):
-        val = apply(windows2c.wxNotebook_AddPage,(self.this,arg0.this,arg1,)+args)
-        return val
-    def InsertPage(self,arg0,arg1,arg2,*args):
-        val = apply(windows2c.wxNotebook_InsertPage,(self.this,arg0,arg1.this,arg2,)+args)
-        return val
-    def GetPage(self,arg0):
-        val = windows2c.wxNotebook_GetPage(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxNotebook instance>"
-class wxNotebook(wxNotebookPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxNotebook,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxSplitterWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetBorderSize(self):
-        val = windows2c.wxSplitterWindow_GetBorderSize(self.this)
-        return val
-    def GetMinimumPaneSize(self):
-        val = windows2c.wxSplitterWindow_GetMinimumPaneSize(self.this)
-        return val
-    def GetSashPosition(self):
-        val = windows2c.wxSplitterWindow_GetSashPosition(self.this)
-        return val
-    def GetSashSize(self):
-        val = windows2c.wxSplitterWindow_GetSashSize(self.this)
-        return val
-    def GetSplitMode(self):
-        val = windows2c.wxSplitterWindow_GetSplitMode(self.this)
-        return val
-    def GetWindow1(self):
-        val = windows2c.wxSplitterWindow_GetWindow1(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def GetWindow2(self):
-        val = windows2c.wxSplitterWindow_GetWindow2(self.this)
-        val = wxWindowPtr(val)
-        return val
-    def Initialize(self,arg0):
-        val = windows2c.wxSplitterWindow_Initialize(self.this,arg0.this)
-        return val
-    def IsSplit(self):
-        val = windows2c.wxSplitterWindow_IsSplit(self.this)
-        return val
-    def SetBorderSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetBorderSize(self.this,arg0)
-        return val
-    def SetSashPosition(self,arg0,*args):
-        val = apply(windows2c.wxSplitterWindow_SetSashPosition,(self.this,arg0,)+args)
-        return val
-    def SetSashSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetSashSize(self.this,arg0)
-        return val
-    def SetMinimumPaneSize(self,arg0):
-        val = windows2c.wxSplitterWindow_SetMinimumPaneSize(self.this,arg0)
-        return val
-    def SetSplitMode(self,arg0):
-        val = windows2c.wxSplitterWindow_SetSplitMode(self.this,arg0)
-        return val
-    def SplitHorizontally(self,arg0,arg1,*args):
-        val = apply(windows2c.wxSplitterWindow_SplitHorizontally,(self.this,arg0.this,arg1.this,)+args)
-        return val
-    def SplitVertically(self,arg0,arg1,*args):
-        val = apply(windows2c.wxSplitterWindow_SplitVertically,(self.this,arg0.this,arg1.this,)+args)
-        return val
-    def Unsplit(self,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows2c.wxSplitterWindow_Unsplit,(self.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxSplitterWindow instance>"
-class wxSplitterWindow(wxSplitterWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows2c.new_wxSplitterWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxTaskBarIconPtr(wxEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            windows2c.delete_wxTaskBarIcon(self.this)
-    def SetIcon(self,arg0,*args):
-        val = apply(windows2c.wxTaskBarIcon_SetIcon,(self.this,arg0.this,)+args)
-        return val
-    def RemoveIcon(self):
-        val = windows2c.wxTaskBarIcon_RemoveIcon(self.this)
-        return val
-    def PopupMenu(self,arg0):
-        val = windows2c.wxTaskBarIcon_PopupMenu(self.this,arg0.this)
-        return val
-    def __repr__(self):
-        return "<C wxTaskBarIcon instance>"
-class wxTaskBarIcon(wxTaskBarIconPtr):
-    def __init__(self) :
-        self.this = windows2c.new_wxTaskBarIcon()
-        self.thisown = 1
-        wx._checkForCallback(self, 'OnMouseMove',    wxEVT_TASKBAR_MOVE)
-        wx._checkForCallback(self, 'OnLButtonDown',  wxEVT_TASKBAR_LEFT_DOWN)
-        wx._checkForCallback(self, 'OnLButtonUp',    wxEVT_TASKBAR_LEFT_UP)
-        wx._checkForCallback(self, 'OnRButtonDown',  wxEVT_TASKBAR_RIGHT_DOWN)
-        wx._checkForCallback(self, 'OnRButtonUp',    wxEVT_TASKBAR_RIGHT_UP)
-        wx._checkForCallback(self, 'OnLButtonDClick',wxEVT_TASKBAR_LEFT_DCLICK)
-        wx._checkForCallback(self, 'OnRButtonDClick',wxEVT_TASKBAR_RIGHT_DCLICK)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-wxGRID_TEXT_CTRL = windows2c.wxGRID_TEXT_CTRL
-wxGRID_HSCROLL = windows2c.wxGRID_HSCROLL
-wxGRID_VSCROLL = windows2c.wxGRID_VSCROLL
-wxEVT_GRID_SELECT_CELL = windows2c.wxEVT_GRID_SELECT_CELL
-wxEVT_GRID_CREATE_CELL = windows2c.wxEVT_GRID_CREATE_CELL
-wxEVT_GRID_CHANGE_LABELS = windows2c.wxEVT_GRID_CHANGE_LABELS
-wxEVT_GRID_CHANGE_SEL_LABEL = windows2c.wxEVT_GRID_CHANGE_SEL_LABEL
-wxEVT_GRID_CELL_CHANGE = windows2c.wxEVT_GRID_CELL_CHANGE
-wxEVT_GRID_CELL_LCLICK = windows2c.wxEVT_GRID_CELL_LCLICK
-wxEVT_GRID_CELL_RCLICK = windows2c.wxEVT_GRID_CELL_RCLICK
-wxEVT_GRID_LABEL_LCLICK = windows2c.wxEVT_GRID_LABEL_LCLICK
-wxEVT_GRID_LABEL_RCLICK = windows2c.wxEVT_GRID_LABEL_RCLICK
-wxEVT_TASKBAR_MOVE = windows2c.wxEVT_TASKBAR_MOVE
-wxEVT_TASKBAR_LEFT_DOWN = windows2c.wxEVT_TASKBAR_LEFT_DOWN
-wxEVT_TASKBAR_LEFT_UP = windows2c.wxEVT_TASKBAR_LEFT_UP
-wxEVT_TASKBAR_RIGHT_DOWN = windows2c.wxEVT_TASKBAR_RIGHT_DOWN
-wxEVT_TASKBAR_RIGHT_UP = windows2c.wxEVT_TASKBAR_RIGHT_UP
-wxEVT_TASKBAR_LEFT_DCLICK = windows2c.wxEVT_TASKBAR_LEFT_DCLICK
-wxEVT_TASKBAR_RIGHT_DCLICK = windows2c.wxEVT_TASKBAR_RIGHT_DCLICK

utils/wxPython/src/msw/windows3.py

@@ -1,293 +0,0 @@
-# This file was created automatically by SWIG.
-import windows3c
-
-from misc import *
-
-from gdi import *
-
-from windows import *
-
-from windows2 import *
-
-from controls import *
-
-from events import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-import wx
-class wxSashEventPtr(wxCommandEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetEdge(self,arg0):
-        val = windows3c.wxSashEvent_SetEdge(self.this,arg0)
-        return val
-    def GetEdge(self):
-        val = windows3c.wxSashEvent_GetEdge(self.this)
-        return val
-    def SetDragRect(self,arg0):
-        val = windows3c.wxSashEvent_SetDragRect(self.this,arg0.this)
-        return val
-    def GetDragRect(self):
-        val = windows3c.wxSashEvent_GetDragRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def SetDragStatus(self,arg0):
-        val = windows3c.wxSashEvent_SetDragStatus(self.this,arg0)
-        return val
-    def GetDragStatus(self):
-        val = windows3c.wxSashEvent_GetDragStatus(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxSashEvent instance>"
-class wxSashEvent(wxSashEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSashWindowPtr(wxWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetSashVisible(self,arg0):
-        val = windows3c.wxSashWindow_GetSashVisible(self.this,arg0)
-        return val
-    def GetDefaultBorderSize(self):
-        val = windows3c.wxSashWindow_GetDefaultBorderSize(self.this)
-        return val
-    def GetEdgeMargin(self,arg0):
-        val = windows3c.wxSashWindow_GetEdgeMargin(self.this,arg0)
-        return val
-    def GetExtraBorderSize(self):
-        val = windows3c.wxSashWindow_GetExtraBorderSize(self.this)
-        return val
-    def GetMaximumSizeX(self):
-        val = windows3c.wxSashWindow_GetMaximumSizeX(self.this)
-        return val
-    def GetMaximumSizeY(self):
-        val = windows3c.wxSashWindow_GetMaximumSizeY(self.this)
-        return val
-    def GetMinimumSizeX(self):
-        val = windows3c.wxSashWindow_GetMinimumSizeX(self.this)
-        return val
-    def GetMinimumSizeY(self):
-        val = windows3c.wxSashWindow_GetMinimumSizeY(self.this)
-        return val
-    def HasBorder(self,arg0):
-        val = windows3c.wxSashWindow_HasBorder(self.this,arg0)
-        return val
-    def SetDefaultBorderSize(self,arg0):
-        val = windows3c.wxSashWindow_SetDefaultBorderSize(self.this,arg0)
-        return val
-    def SetExtraBorderSize(self,arg0):
-        val = windows3c.wxSashWindow_SetExtraBorderSize(self.this,arg0)
-        return val
-    def SetMaximumSizeX(self,arg0):
-        val = windows3c.wxSashWindow_SetMaximumSizeX(self.this,arg0)
-        return val
-    def SetMaximumSizeY(self,arg0):
-        val = windows3c.wxSashWindow_SetMaximumSizeY(self.this,arg0)
-        return val
-    def SetMinimumSizeX(self,arg0):
-        val = windows3c.wxSashWindow_SetMinimumSizeX(self.this,arg0)
-        return val
-    def SetMinimumSizeY(self,arg0):
-        val = windows3c.wxSashWindow_SetMinimumSizeY(self.this,arg0)
-        return val
-    def SetSashVisible(self,arg0,arg1):
-        val = windows3c.wxSashWindow_SetSashVisible(self.this,arg0,arg1)
-        return val
-    def SetSashBorder(self,arg0,arg1):
-        val = windows3c.wxSashWindow_SetSashBorder(self.this,arg0,arg1)
-        return val
-    def __repr__(self):
-        return "<C wxSashWindow instance>"
-class wxSashWindow(wxSashWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows3c.new_wxSashWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-
-
-
-
-class wxQueryLayoutInfoEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetRequestedLength(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetRequestedLength(self.this,arg0)
-        return val
-    def GetRequestedLength(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetRequestedLength(self.this)
-        return val
-    def SetFlags(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetFlags(self.this,arg0)
-        return val
-    def GetFlags(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetFlags(self.this)
-        return val
-    def SetSize(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetSize(self.this,arg0.this)
-        return val
-    def GetSize(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetSize(self.this)
-        val = wxSizePtr(val)
-        val.thisown = 1
-        return val
-    def SetOrientation(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetOrientation(self.this,arg0)
-        return val
-    def GetOrientation(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetOrientation(self.this)
-        return val
-    def SetAlignment(self,arg0):
-        val = windows3c.wxQueryLayoutInfoEvent_SetAlignment(self.this,arg0)
-        return val
-    def GetAlignment(self):
-        val = windows3c.wxQueryLayoutInfoEvent_GetAlignment(self.this)
-        return val
-    def __repr__(self):
-        return "<C wxQueryLayoutInfoEvent instance>"
-class wxQueryLayoutInfoEvent(wxQueryLayoutInfoEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxCalculateLayoutEventPtr(wxEventPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetFlags(self,arg0):
-        val = windows3c.wxCalculateLayoutEvent_SetFlags(self.this,arg0)
-        return val
-    def GetFlags(self):
-        val = windows3c.wxCalculateLayoutEvent_GetFlags(self.this)
-        return val
-    def SetRect(self,arg0):
-        val = windows3c.wxCalculateLayoutEvent_SetRect(self.this,arg0.this)
-        return val
-    def GetRect(self):
-        val = windows3c.wxCalculateLayoutEvent_GetRect(self.this)
-        val = wxRectPtr(val)
-        val.thisown = 1
-        return val
-    def __repr__(self):
-        return "<C wxCalculateLayoutEvent instance>"
-class wxCalculateLayoutEvent(wxCalculateLayoutEventPtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-class wxSashLayoutWindowPtr(wxSashWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def GetAlignment(self):
-        val = windows3c.wxSashLayoutWindow_GetAlignment(self.this)
-        return val
-    def GetOrientation(self):
-        val = windows3c.wxSashLayoutWindow_GetOrientation(self.this)
-        return val
-    def SetAlignment(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetAlignment(self.this,arg0)
-        return val
-    def SetDefaultSize(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetDefaultSize(self.this,arg0.this)
-        return val
-    def SetOrientation(self,arg0):
-        val = windows3c.wxSashLayoutWindow_SetOrientation(self.this,arg0)
-        return val
-    def __repr__(self):
-        return "<C wxSashLayoutWindow instance>"
-class wxSashLayoutWindow(wxSashLayoutWindowPtr):
-    def __init__(self,arg0,arg1,*args) :
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        try: argl[1] = argl[1].this
-        except: pass
-        args = tuple(argl)
-        self.this = apply(windows3c.new_wxSashLayoutWindow,(arg0.this,arg1,)+args)
-        self.thisown = 1
-        wx._StdWindowCallbacks(self)
-        wx._checkForCallback(self, 'OnCalculateLayout',    wxEVT_CALCULATE_LAYOUT)
-        wx._checkForCallback(self, 'OnQueryLayoutInfo',    wxEVT_QUERY_LAYOUT_INFO)
-
-
-
-
-class wxLayoutAlgorithmPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self):
-        if self.thisown == 1 :
-            windows3c.delete_wxLayoutAlgorithm(self.this)
-    def LayoutMDIFrame(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows3c.wxLayoutAlgorithm_LayoutMDIFrame,(self.this,arg0.this,)+args)
-        return val
-    def LayoutFrame(self,arg0,*args):
-        argl = map(None,args)
-        try: argl[0] = argl[0].this
-        except: pass
-        args = tuple(argl)
-        val = apply(windows3c.wxLayoutAlgorithm_LayoutFrame,(self.this,arg0.this,)+args)
-        return val
-    def __repr__(self):
-        return "<C wxLayoutAlgorithm instance>"
-class wxLayoutAlgorithm(wxLayoutAlgorithmPtr):
-    def __init__(self) :
-        self.this = windows3c.new_wxLayoutAlgorithm()
-        self.thisown = 1
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-wxSASH_TOP = windows3c.wxSASH_TOP
-wxSASH_RIGHT = windows3c.wxSASH_RIGHT
-wxSASH_BOTTOM = windows3c.wxSASH_BOTTOM
-wxSASH_LEFT = windows3c.wxSASH_LEFT
-wxSASH_NONE = windows3c.wxSASH_NONE
-wxEVT_SASH_DRAGGED = windows3c.wxEVT_SASH_DRAGGED
-wxSW_3D = windows3c.wxSW_3D
-wxSASH_STATUS_OK = windows3c.wxSASH_STATUS_OK
-wxSASH_STATUS_OUT_OF_RANGE = windows3c.wxSASH_STATUS_OUT_OF_RANGE
-wxLAYOUT_HORIZONTAL = windows3c.wxLAYOUT_HORIZONTAL
-wxLAYOUT_VERTICAL = windows3c.wxLAYOUT_VERTICAL
-wxLAYOUT_NONE = windows3c.wxLAYOUT_NONE
-wxLAYOUT_TOP = windows3c.wxLAYOUT_TOP
-wxLAYOUT_LEFT = windows3c.wxLAYOUT_LEFT
-wxLAYOUT_RIGHT = windows3c.wxLAYOUT_RIGHT
-wxLAYOUT_BOTTOM = windows3c.wxLAYOUT_BOTTOM
-wxEVT_QUERY_LAYOUT_INFO = windows3c.wxEVT_QUERY_LAYOUT_INFO
-wxEVT_CALCULATE_LAYOUT = windows3c.wxEVT_CALCULATE_LAYOUT