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

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

src/regex/COPYRIGHT

@@ -0,0 +1,20 @@
+Copyright 1992, 1993, 1994, 1997 Henry Spencer.  All rights reserved.
+This software is not subject to any license of the American Telephone
+and Telegraph Company or of the Regents of the University of California.
+
+Permission is granted to anyone to use this software for any purpose on
+any computer system, and to alter it and redistribute it, subject
+to the following restrictions:
+
+1. The author is not responsible for the consequences of use of this
+   software, no matter how awful, even if they arise from flaws in it.
+
+2. The origin of this software must not be misrepresented, either by
+   explicit claim or by omission.  Since few users ever read sources,
+   credits must appear in the documentation.
+
+3. Altered versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.  Since few users
+   ever read sources, credits must appear in the documentation.
+
+4. This notice may not be removed or altered.

src/regex/Makefile

@@ -0,0 +1,130 @@
+# You probably want to take -DREDEBUG out of CFLAGS, and put something like
+# -O in, *after* testing (-DREDEBUG strengthens testing by enabling a lot of
+# internal assertion checking and some debugging facilities).
+# Put -Dconst= in for a pre-ANSI compiler.
+# Do not take -DPOSIX_MISTAKE out.
+# REGCFLAGS isn't important to you (it's for my use in some special contexts).
+CFLAGS=-I. -DPOSIX_MISTAKE -DREDEBUG $(REGCFLAGS)
+
+# If you have a pre-ANSI compiler, put -o into MKHFLAGS.  If you want
+# the Berkeley __P macro, put -b in.
+MKHFLAGS=
+
+# Flags for linking but not compiling, if any.
+LDFLAGS=
+
+# Extra libraries for linking, if any.
+LIBS=
+
+# Internal stuff, should not need changing.
+OBJPRODN=regcomp.o regexec.o regerror.o regfree.o
+OBJS=$(OBJPRODN) split.o debug.o main.o
+H=cclass.h cname.h regex2.h utils.h
+REGSRC=regcomp.c regerror.c regexec.c regfree.c
+ALLSRC=$(REGSRC) engine.c debug.c main.c split.c
+
+# Stuff that matters only if you're trying to lint the package.
+LINTFLAGS=-I. -Dstatic= -Dconst= -DREDEBUG
+LINTC=regcomp.c regexec.c regerror.c regfree.c debug.c main.c
+JUNKLINT=possible pointer alignment|null effect
+
+# arrangements to build forward-reference header files
+.SUFFIXES:	.ih .h
+.c.ih:
+	sh ./mkh $(MKHFLAGS) -p $< >$@
+
+default:	r
+
+lib:	purge $(OBJPRODN)
+	rm -f libregex.a
+	ar crv libregex.a $(OBJPRODN)
+
+purge:
+	rm -f *.o
+
+# stuff to build regex.h
+REGEXH=regex.h
+REGEXHSRC=regex2.h $(REGSRC)
+$(REGEXH):	$(REGEXHSRC) mkh
+	sh ./mkh $(MKHFLAGS) -i _REGEX_H_ $(REGEXHSRC) >regex.tmp
+	cmp -s regex.tmp regex.h 2>/dev/null || cp regex.tmp regex.h
+	rm -f regex.tmp
+
+# dependencies
+$(OBJPRODN) debug.o:	utils.h regex.h regex2.h
+regcomp.o:	cclass.h cname.h regcomp.ih
+regexec.o:	engine.c engine.ih
+regerror.o:	regerror.ih
+debug.o:	debug.ih
+main.o:	main.ih
+
+# tester
+re:	$(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
+
+# regression test
+r:	re tests
+	./re <tests
+	./re -el <tests
+	./re -er <tests
+
+# 57 variants, and other stuff, for development use -- not useful to you
+ra:	./re tests
+	-./re <tests
+	-./re -el <tests
+	-./re -er <tests
+
+rx:	./re tests
+	./re -x <tests
+	./re -x -el <tests
+	./re -x -er <tests
+
+t:	./re tests
+	-time ./re <tests
+	-time ./re -cs <tests
+	-time ./re -el <tests
+	-time ./re -cs -el <tests
+
+l:	$(LINTC)
+	lint $(LINTFLAGS) -h $(LINTC) 2>&1 | egrep -v '$(JUNKLINT)' | tee lint
+
+fullprint:
+	ti README WHATSNEW notes todo | list
+	ti *.h | list
+	list *.c
+	list regex.3 regex.7
+
+print:
+	ti README WHATSNEW notes todo | list
+	ti *.h | list
+	list reg*.c engine.c
+
+
+mf.tmp:	Makefile
+	sed '/^REGEXH=/s/=.*/=regex.h/' Makefile | sed '/#DEL$$/d' >$@
+
+DTRH=cclass.h cname.h regex2.h utils.h
+PRE=COPYRIGHT README WHATSNEW
+POST=mkh regex.3 regex.7 tests $(DTRH) $(ALLSRC) fake/*.[ch]
+FILES=$(PRE) Makefile $(POST)
+DTR=$(PRE) Makefile=mf.tmp $(POST)
+dtr:	$(FILES) mf.tmp
+	makedtr $(DTR) >$@
+	rm mf.tmp
+
+cio:	$(FILES)
+	cio $(FILES)
+
+rdf:	$(FILES)
+	rcsdiff -c $(FILES) 2>&1 | p
+
+# various forms of cleanup
+tidy:
+	rm -f junk* core core.* *.core dtr *.tmp lint
+
+clean:	tidy
+	rm -f *.o *.s *.ih re libregex.a
+
+# don't do this one unless you know what you're doing
+spotless:	clean
+	rm -f mkh regex.h

src/regex/README

@@ -0,0 +1,32 @@
+alpha3.8 release.
+Tue Aug 10 15:51:48 EDT 1999
+henry@spsystems.net  (formerly henry@zoo.toronto.edu)
+
+See WHATSNEW for change listing.
+
+installation notes:
+--------
+Read the comments at the beginning of Makefile before running.
+
+Utils.h contains some things that just might have to be modified on
+some systems, as well as a nested include (ugh) of <assert.h>.
+
+The "fake" directory contains quick-and-dirty fakes for some header
+files and routines that old systems may not have.  Note also that
+-DUSEBCOPY will make utils.h substitute bcopy() for memmove().
+
+After that, "make r" will build regcomp.o, regexec.o, regfree.o,
+and regerror.o (the actual routines), bundle them together into a test
+program, and run regression tests on them.  No output is good output.
+
+"make lib" builds just the .o files for the actual routines (when
+you're happy with testing and have adjusted CFLAGS for production),
+and puts them together into libregex.a.  You can pick up either the
+library or *.o ("make lib" makes sure there are no other .o files left
+around to confuse things).
+
+Main.c, debug.c, split.c are used for regression testing but are not part
+of the RE routines themselves.
+
+Regex.h goes in /usr/include.  All other .h files are internal only.
+--------

src/regex/WHATSNEW

@@ -0,0 +1,108 @@
+New in alpha3.8:  Bug fix for signed/unsigned mixup, found and fixed
+by the FreeBSD folks.
+
+New in alpha3.7:  A bit of cleanup aimed at maximizing portability,
+possibly at slight cost in efficiency.  "ul" suffixes and "unsigned long"
+no longer appear, in particular.
+
+New in alpha3.6:  A couple more portability glitches fixed.
+
+New in alpha3.5:  Active development of this code has been stopped --
+I'm working on a complete reimplementation -- but folks have found some
+minor portability glitches and the like, hence this release to fix them.
+One penalty:  slightly reduced compatibility with old compilers, because
+the ANSI C `unsigned long' type and `ul' constant suffix are used in a
+few places (I could avoid this but it would be considerably more work).
+
+New in alpha3.4:  The complex bug alluded to below has been fixed (in a
+slightly kludgey temporary way that may hurt efficiency a bit; this is
+another "get it out the door for 4.4" release).  The tests at the end of
+the tests file have accordingly been uncommented.  The primary sign of
+the bug was that something like a?b matching ab matched b rather than ab.
+(The bug was essentially specific to this exact situation, else it would
+have shown up earlier.)
+
+New in alpha3.3:  The definition of word boundaries has been altered
+slightly, to more closely match the usual programming notion that "_"
+is an alphabetic.  Stuff used for pre-ANSI systems is now in a subdir,
+and the makefile no longer alludes to it in mysterious ways.  The
+makefile has generally been cleaned up some.  Fixes have been made
+(again!) so that the regression test will run without -DREDEBUG, at
+the cost of weaker checking.  A workaround for a bug in some folks'
+<assert.h> has been added.  And some more things have been added to
+tests, including a couple right at the end which are commented out
+because the code currently flunks them (complex bug; fix coming).
+Plus the usual minor cleanup.
+
+New in alpha3.2:  Assorted bits of cleanup and portability improvement
+(the development base is now a BSDI system using GCC instead of an ancient
+Sun system, and the newer compiler exposed some glitches).  Fix for a
+serious bug that affected REs using many [] (including REG_ICASE REs
+because of the way they are implemented), *sometimes*, depending on
+memory-allocation patterns.  The header-file prototypes no longer name
+the parameters, avoiding possible name conflicts.  The possibility that
+some clot has defined CHAR_MIN as (say) `-128' instead of `(-128)' is
+now handled gracefully.  "uchar" is no longer used as an internal type
+name (too many people have the same idea).  Still the same old lousy
+performance, alas.
+
+New in alpha3.1:  Basically nothing, this release is just a bookkeeping
+convenience.  Stay tuned.
+
+New in alpha3.0:  Performance is no better, alas, but some fixes have been
+made and some functionality has been added.  (This is basically the "get
+it out the door in time for 4.4" release.)  One bug fix:  regfree() didn't
+free the main internal structure (how embarrassing).  It is now possible
+to put NULs in either the RE or the target string, using (resp.) a new
+REG_PEND flag and the old REG_STARTEND flag.  The REG_NOSPEC flag to
+regcomp() makes all characters ordinary, so you can match a literal
+string easily (this will become more useful when performance improves!).
+There are now primitives to match beginnings and ends of words, although
+the syntax is disgusting and so is the implementation.  The REG_ATOI
+debugging interface has changed a bit.  And there has been considerable
+internal cleanup of various kinds.
+
+New in alpha2.3:  Split change list out of README, and moved flags notes
+into Makefile.  Macro-ized the name of regex(7) in regex(3), since it has
+to change for 4.4BSD.  Cleanup work in engine.c, and some new regression
+tests to catch tricky cases thereof.
+
+New in alpha2.2:  Out-of-date manpages updated.  Regerror() acquires two
+small extensions -- REG_ITOA and REG_ATOI -- which avoid debugging kludges
+in my own test program and might be useful to others for similar purposes.
+The regression test will now compile (and run) without REDEBUG.  The
+BRE \$ bug is fixed.  Most uses of "uchar" are gone; it's all chars now.
+Char/uchar parameters are now written int/unsigned, to avoid possible
+portability problems with unpromoted parameters.  Some unsigned casts have
+been introduced to minimize portability problems with shifting into sign
+bits.
+
+New in alpha2.1:  Lots of little stuff, cleanup and fixes.  The one big
+thing is that regex.h is now generated, using mkh, rather than being
+supplied in the distribution; due to circularities in dependencies,
+you have to build regex.h explicitly by "make h".  The two known bugs
+have been fixed (and the regression test now checks for them), as has a
+problem with assertions not being suppressed in the absence of REDEBUG.
+No performance work yet.
+
+New in alpha2:  Backslash-anything is an ordinary character, not an
+error (except, of course, for the handful of backslashed metacharacters
+in BREs), which should reduce script breakage.  The regression test
+checks *where* null strings are supposed to match, and has generally
+been tightened up somewhat.  Small bug fixes in parameter passing (not
+harmful, but technically errors) and some other areas.  Debugging
+invoked by defining REDEBUG rather than not defining NDEBUG.
+
+New in alpha+3:  full prototyping for internal routines, using a little
+helper program, mkh, which extracts prototypes given in stylized comments.
+More minor cleanup.  Buglet fix:  it's CHAR_BIT, not CHAR_BITS.  Simple
+pre-screening of input when a literal string is known to be part of the
+RE; this does wonders for performance.
+
+New in alpha+2:  minor bits of cleanup.  Notably, the number "32" for the
+word width isn't hardwired into regexec.c any more, the public header
+file prototypes the functions if __STDC__ is defined, and some small typos
+in the manpages have been fixed.
+
+New in alpha+1:  improvements to the manual pages, and an important
+extension, the REG_STARTEND option to regexec().

src/regex/cclass.h

@@ -0,0 +1,31 @@
+/* character-class table */
+static struct cclass {
+	char *name;
+	char *chars;
+	char *multis;
+} cclasses[] = {
+	"alnum",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789",				"",
+	"alpha",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+					"",
+	"blank",	" \t",		"",
+	"cntrl",	"\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
+\25\26\27\30\31\32\33\34\35\36\37\177",	"",
+	"digit",	"0123456789",	"",
+	"graph",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+					"",
+	"lower",	"abcdefghijklmnopqrstuvwxyz",
+					"",
+	"print",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
+					"",
+	"punct",	"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+					"",
+	"space",	"\t\n\v\f\r ",	"",
+	"upper",	"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+					"",
+	"xdigit",	"0123456789ABCDEFabcdef",
+					"",
+	NULL,		0,		""
+};

src/regex/cname.h

@@ -0,0 +1,102 @@
+/* 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,
+};

src/regex/debug.c

@@ -0,0 +1,242 @@
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+#include "debug.ih"
+
+/*
+ - regprint - print a regexp for debugging
+ == void regprint(regex_t *r, FILE *d);
+ */
+void
+regprint(r, d)
+regex_t *r;
+FILE *d;
+{
+	register struct re_guts *g = r->re_g;
+	register int i;
+	register int c;
+	register int last;
+	int nincat[NC];
+
+	fprintf(d, "%ld states, %d categories", (long)g->nstates,
+							g->ncategories);
+	fprintf(d, ", first %ld last %ld", (long)g->firststate,
+						(long)g->laststate);
+	if (g->iflags&USEBOL)
+		fprintf(d, ", USEBOL");
+	if (g->iflags&USEEOL)
+		fprintf(d, ", USEEOL");
+	if (g->iflags&BAD)
+		fprintf(d, ", BAD");
+	if (g->nsub > 0)
+		fprintf(d, ", nsub=%ld", (long)g->nsub);
+	if (g->must != NULL)
+		fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
+								g->must);
+	if (g->backrefs)
+		fprintf(d, ", backrefs");
+	if (g->nplus > 0)
+		fprintf(d, ", nplus %ld", (long)g->nplus);
+	fprintf(d, "\n");
+	s_print(g, d);
+	for (i = 0; i < g->ncategories; i++) {
+		nincat[i] = 0;
+		for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+			if (g->categories[c] == i)
+				nincat[i]++;
+	}
+	fprintf(d, "cc0#%d", nincat[0]);
+	for (i = 1; i < g->ncategories; i++)
+		if (nincat[i] == 1) {
+			for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+				if (g->categories[c] == i)
+					break;
+			fprintf(d, ", %d=%s", i, regchar(c));
+		}
+	fprintf(d, "\n");
+	for (i = 1; i < g->ncategories; i++)
+		if (nincat[i] != 1) {
+			fprintf(d, "cc%d\t", i);
+			last = -1;
+			for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)	/* +1 does flush */
+				if (c <= CHAR_MAX && g->categories[c] == i) {
+					if (last < 0) {
+						fprintf(d, "%s", regchar(c));
+						last = c;
+					}
+				} else {
+					if (last >= 0) {
+						if (last != c-1)
+							fprintf(d, "-%s",
+								regchar(c-1));
+						last = -1;
+					}
+				}
+			fprintf(d, "\n");
+		}
+}
+
+/*
+ - s_print - print the strip for debugging
+ == static void s_print(register struct re_guts *g, FILE *d);
+ */
+static void
+s_print(g, d)
+register struct re_guts *g;
+FILE *d;
+{
+	register sop *s;
+	register cset *cs;
+	register int i;
+	register int done = 0;
+	register sop opnd;
+	register int col = 0;
+	register int last;
+	register sopno offset = 2;
+#	define	GAP()	{	if (offset % 5 == 0) { \
+					if (col > 40) { \
+						fprintf(d, "\n\t"); \
+						col = 0; \
+					} else { \
+						fprintf(d, " "); \
+						col++; \
+					} \
+				} else \
+					col++; \
+				offset++; \
+			}
+
+	if (OP(g->strip[0]) != OEND)
+		fprintf(d, "missing initial OEND!\n");
+	for (s = &g->strip[1]; !done; s++) {
+		opnd = OPND(*s);
+		switch (OP(*s)) {
+		case OEND:
+			fprintf(d, "\n");
+			done = 1;
+			break;
+		case OCHAR:
+			if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
+				fprintf(d, "\\%c", (char)opnd);
+			else
+				fprintf(d, "%s", regchar((char)opnd));
+			break;
+		case OBOL:
+			fprintf(d, "^");
+			break;
+		case OEOL:
+			fprintf(d, "$");
+			break;
+		case OBOW:
+			fprintf(d, "\\{");
+			break;
+		case OEOW:
+			fprintf(d, "\\}");
+			break;
+		case OANY:
+			fprintf(d, ".");
+			break;
+		case OANYOF:
+			fprintf(d, "[(%ld)", (long)opnd);
+			cs = &g->sets[opnd];
+			last = -1;
+			for (i = 0; i < g->csetsize+1; i++)	/* +1 flushes */
+				if (CHIN(cs, i) && i < g->csetsize) {
+					if (last < 0) {
+						fprintf(d, "%s", regchar(i));
+						last = i;
+					}
+				} else {
+					if (last >= 0) {
+						if (last != i-1)
+							fprintf(d, "-%s",
+								regchar(i-1));
+						last = -1;
+					}
+				}
+			fprintf(d, "]");
+			break;
+		case OBACK_:
+			fprintf(d, "(\\<%ld>", (long)opnd);
+			break;
+		case O_BACK:
+			fprintf(d, "<%ld>\\)", (long)opnd);
+			break;
+		case OPLUS_:
+			fprintf(d, "(+");
+			if (OP(*(s+opnd)) != O_PLUS)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case O_PLUS:
+			if (OP(*(s-opnd)) != OPLUS_)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, "+)");
+			break;
+		case OQUEST_:
+			fprintf(d, "(?");
+			if (OP(*(s+opnd)) != O_QUEST)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case O_QUEST:
+			if (OP(*(s-opnd)) != OQUEST_)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, "?)");
+			break;
+		case OLPAREN:
+			fprintf(d, "((<%ld>", (long)opnd);
+			break;
+		case ORPAREN:
+			fprintf(d, "<%ld>))", (long)opnd);
+			break;
+		case OCH_:
+			fprintf(d, "<");
+			if (OP(*(s+opnd)) != OOR2)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case OOR1:
+			if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, "|");
+			break;
+		case OOR2:
+			fprintf(d, "|");
+			if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case O_CH:
+			if (OP(*(s-opnd)) != OOR1)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, ">");
+			break;
+		default:
+			fprintf(d, "!%d(%d)!", OP(*s), opnd);
+			break;
+		}
+		if (!done)
+			GAP();
+	}
+}
+
+/*
+ - regchar - make a character printable
+ == static char *regchar(int ch);
+ */
+static char *			/* -> representation */
+regchar(ch)
+int ch;
+{
+	static char buf[10];
+
+	if (isprint(ch) || ch == ' ')
+		sprintf(buf, "%c", ch);
+	else
+		sprintf(buf, "\\%o", ch);
+	return(buf);
+}

src/regex/main.c

@@ -0,0 +1,510 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <regex.h>
+#include <assert.h>
+
+#include "main.ih"
+
+char *progname;
+int debug = 0;
+int line = 0;
+int status = 0;
+
+int copts = REG_EXTENDED;
+int eopts = 0;
+regoff_t startoff = 0;
+regoff_t endoff = 0;
+
+
+extern int split();
+extern void regprint();
+
+/*
+ - main - do the simple case, hand off to regress() for regression
+ */
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	regex_t re;
+#	define	NS	10
+	regmatch_t subs[NS];
+	char erbuf[100];
+	int err;
+	size_t len;
+	int c;
+	int errflg = 0;
+	register int i;
+	extern int optind;
+	extern char *optarg;
+
+	progname = argv[0];
+
+	while ((c = getopt(argc, argv, "c:e:S:E:x")) != EOF)
+		switch (c) {
+		case 'c':	/* compile options */
+			copts = options('c', optarg);
+			break;
+		case 'e':	/* execute options */
+			eopts = options('e', optarg);
+			break;
+		case 'S':	/* start offset */
+			startoff = (regoff_t)atoi(optarg);
+			break;
+		case 'E':	/* end offset */
+			endoff = (regoff_t)atoi(optarg);
+			break;
+		case 'x':	/* Debugging. */
+			debug++;
+			break;
+		case '?':
+		default:
+			errflg++;
+			break;
+		}
+	if (errflg) {
+		fprintf(stderr, "usage: %s ", progname);
+		fprintf(stderr, "[-c copt][-C][-d] [re]\n");
+		exit(2);
+	}
+
+	if (optind >= argc) {
+		regress(stdin);
+		exit(status);
+	}
+
+	err = regcomp(&re, argv[optind++], copts);
+	if (err) {
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "error %s, %d/%d `%s'\n",
+			eprint(err), len, sizeof(erbuf), erbuf);
+		exit(status);
+	}
+	regprint(&re, stdout);	
+
+	if (optind >= argc) {
+		regfree(&re);
+		exit(status);
+	}
+
+	if (eopts&REG_STARTEND) {
+		subs[0].rm_so = startoff;
+		subs[0].rm_eo = strlen(argv[optind]) - endoff;
+	}
+	err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
+	if (err) {
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "error %s, %d/%d `%s'\n",
+			eprint(err), len, sizeof(erbuf), erbuf);
+		exit(status);
+	}
+	if (!(copts&REG_NOSUB)) {
+		len = (int)(subs[0].rm_eo - subs[0].rm_so);
+		if (subs[0].rm_so != -1) {
+			if (len != 0)
+				printf("match `%.*s'\n", len,
+					argv[optind] + subs[0].rm_so);
+			else
+				printf("match `'@%.1s\n",
+					argv[optind] + subs[0].rm_so);
+		}
+		for (i = 1; i < NS; i++)
+			if (subs[i].rm_so != -1)
+				printf("(%d) `%.*s'\n", i,
+					(int)(subs[i].rm_eo - subs[i].rm_so),
+					argv[optind] + subs[i].rm_so);
+	}
+	exit(status);
+}
+
+/*
+ - regress - main loop of regression test
+ == void regress(FILE *in);
+ */
+void
+regress(in)
+FILE *in;
+{
+	char inbuf[1000];
+#	define	MAXF	10
+	char *f[MAXF];
+	int nf;
+	int i;
+	char erbuf[100];
+	size_t ne;
+	char *badpat = "invalid regular expression";
+#	define	SHORT	10
+	char *bpname = "REG_BADPAT";
+	regex_t re;
+
+	while (fgets(inbuf, sizeof(inbuf), in) != NULL) {
+		line++;
+		if (inbuf[0] == '#' || inbuf[0] == '\n')
+			continue;			/* NOTE CONTINUE */
+		inbuf[strlen(inbuf)-1] = '\0';	/* get rid of stupid \n */
+		if (debug)
+			fprintf(stdout, "%d:\n", line);
+		nf = split(inbuf, f, MAXF, "\t\t");
+		if (nf < 3) {
+			fprintf(stderr, "bad input, line %d\n", line);
+			exit(1);
+		}
+		for (i = 0; i < nf; i++)
+			if (strcmp(f[i], "\"\"") == 0)
+				f[i] = "";
+		if (nf <= 3)
+			f[3] = NULL;
+		if (nf <= 4)
+			f[4] = NULL;
+		try(f[0], f[1], f[2], f[3], f[4], options('c', f[1]));
+		if (opt('&', f[1]))	/* try with either type of RE */
+			try(f[0], f[1], f[2], f[3], f[4],
+					options('c', f[1]) &~ REG_EXTENDED);
+	}
+
+	ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+	if (strcmp(erbuf, badpat) != 0 || ne != strlen(badpat)+1) {
+		fprintf(stderr, "end: regerror() test gave `%s' not `%s'\n",
+							erbuf, badpat);
+		status = 1;
+	}
+	ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, (size_t)SHORT);
+	if (strncmp(erbuf, badpat, SHORT-1) != 0 || erbuf[SHORT-1] != '\0' ||
+						ne != strlen(badpat)+1) {
+		fprintf(stderr, "end: regerror() short test gave `%s' not `%.*s'\n",
+						erbuf, SHORT-1, badpat);
+		status = 1;
+	}
+	ne = regerror(REG_ITOA|REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+	if (strcmp(erbuf, bpname) != 0 || ne != strlen(bpname)+1) {
+		fprintf(stderr, "end: regerror() ITOA test gave `%s' not `%s'\n",
+						erbuf, bpname);
+		status = 1;
+	}
+	re.re_endp = bpname;
+	ne = regerror(REG_ATOI, &re, erbuf, sizeof(erbuf));
+	if (atoi(erbuf) != (int)REG_BADPAT) {
+		fprintf(stderr, "end: regerror() ATOI test gave `%s' not `%ld'\n",
+						erbuf, (long)REG_BADPAT);
+		status = 1;
+	} else if (ne != strlen(erbuf)+1) {
+		fprintf(stderr, "end: regerror() ATOI test len(`%s') = %ld\n",
+						erbuf, (long)REG_BADPAT);
+		status = 1;
+	}
+}
+
+/*
+ - try - try it, and report on problems
+ == void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+ */
+void
+try(f0, f1, f2, f3, f4, opts)
+char *f0;
+char *f1;
+char *f2;
+char *f3;
+char *f4;
+int opts;			/* may not match f1 */
+{
+	regex_t re;
+#	define	NSUBS	10
+	regmatch_t subs[NSUBS];
+#	define	NSHOULD	15
+	char *should[NSHOULD];
+	int nshould;
+	char erbuf[100];
+	int err;
+	int len;
+	char *type = (opts & REG_EXTENDED) ? "ERE" : "BRE";
+	register int i;
+	char *grump;
+	char f0copy[1000];
+	char f2copy[1000];
+
+	strcpy(f0copy, f0);
+	re.re_endp = (opts&REG_PEND) ? f0copy + strlen(f0copy) : NULL;
+	fixstr(f0copy);
+	err = regcomp(&re, f0copy, opts);
+	if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
+		/* unexpected error or wrong error */
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
+					line, type, eprint(err), len,
+					sizeof(erbuf), erbuf);
+		status = 1;
+	} else if (err == 0 && opt('C', f1)) {
+		/* unexpected success */
+		fprintf(stderr, "%d: %s should have given REG_%s\n",
+						line, type, f2);
+		status = 1;
+		err = 1;	/* so we won't try regexec */
+	}
+
+	if (err != 0) {
+		regfree(&re);
+		return;
+	}
+
+	strcpy(f2copy, f2);
+	fixstr(f2copy);
+
+	if (options('e', f1)&REG_STARTEND) {
+		if (strchr(f2, '(') == NULL || strchr(f2, ')') == NULL)
+			fprintf(stderr, "%d: bad STARTEND syntax\n", line);
+		subs[0].rm_so = strchr(f2, '(') - f2 + 1;
+		subs[0].rm_eo = strchr(f2, ')') - f2;
+	}
+	err = regexec(&re, f2copy, NSUBS, subs, options('e', f1));
+
+	if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
+		/* unexpected error or wrong error */
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
+					line, type, eprint(err), len,
+					sizeof(erbuf), erbuf);
+		status = 1;
+	} else if (err != 0) {
+		/* nothing more to check */
+	} else if (f3 == NULL) {
+		/* unexpected success */
+		fprintf(stderr, "%d: %s exec should have failed\n",
+						line, type);
+		status = 1;
+		err = 1;		/* just on principle */
+	} else if (opts&REG_NOSUB) {
+		/* nothing more to check */
+	} else if ((grump = check(f2, subs[0], f3)) != NULL) {
+		fprintf(stderr, "%d: %s %s\n", line, type, grump);
+		status = 1;
+		err = 1;
+	}
+
+	if (err != 0 || f4 == NULL) {
+		regfree(&re);
+		return;
+	}
+
+	for (i = 1; i < NSHOULD; i++)
+		should[i] = NULL;
+	nshould = split(f4, should+1, NSHOULD-1, ",");
+	if (nshould == 0) {
+		nshould = 1;
+		should[1] = "";
+	}
+	for (i = 1; i < NSUBS; i++) {
+		grump = check(f2, subs[i], should[i]);
+		if (grump != NULL) {
+			fprintf(stderr, "%d: %s $%d %s\n", line,
+							type, i, grump);
+			status = 1;
+			err = 1;
+		}
+	}
+
+	regfree(&re);
+}
+
+/*
+ - options - pick options out of a regression-test string
+ == int options(int type, char *s);
+ */
+int
+options(type, s)
+int type;			/* 'c' compile, 'e' exec */
+char *s;
+{
+	register char *p;
+	register int o = (type == 'c') ? copts : eopts;
+	register char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
+
+	for (p = s; *p != '\0'; p++)
+		if (strchr(legal, *p) != NULL)
+			switch (*p) {
+			case 'b':
+				o &= ~REG_EXTENDED;
+				break;
+			case 'i':
+				o |= REG_ICASE;
+				break;
+			case 's':
+				o |= REG_NOSUB;
+				break;
+			case 'n':
+				o |= REG_NEWLINE;
+				break;
+			case 'm':
+				o &= ~REG_EXTENDED;
+				o |= REG_NOSPEC;
+				break;
+			case 'p':
+				o |= REG_PEND;
+				break;
+			case '^':
+				o |= REG_NOTBOL;
+				break;
+			case '$':
+				o |= REG_NOTEOL;
+				break;
+			case '#':
+				o |= REG_STARTEND;
+				break;
+			case 't':	/* trace */
+				o |= REG_TRACE;
+				break;
+			case 'l':	/* force long representation */
+				o |= REG_LARGE;
+				break;
+			case 'r':	/* force backref use */
+				o |= REG_BACKR;
+				break;
+			}
+	return(o);
+}
+
+/*
+ - opt - is a particular option in a regression string?
+ == int opt(int c, char *s);
+ */
+int				/* predicate */
+opt(c, s)
+int c;
+char *s;
+{
+	return(strchr(s, c) != NULL);
+}
+
+/*
+ - fixstr - transform magic characters in strings
+ == void fixstr(register char *p);
+ */
+void
+fixstr(p)
+register char *p;
+{
+	if (p == NULL)
+		return;
+
+	for (; *p != '\0'; p++)
+		if (*p == 'N')
+			*p = '\n';
+		else if (*p == 'T')
+			*p = '\t';
+		else if (*p == 'S')
+			*p = ' ';
+		else if (*p == 'Z')
+			*p = '\0';
+}
+
+/*
+ - check - check a substring match
+ == char *check(char *str, regmatch_t sub, char *should);
+ */
+char *				/* NULL or complaint */
+check(str, sub, should)
+char *str;
+regmatch_t sub;
+char *should;
+{
+	register int len;
+	register int shlen;
+	register char *p;
+	static char grump[500];
+	register char *at = NULL;
+
+	if (should != NULL && strcmp(should, "-") == 0)
+		should = NULL;
+	if (should != NULL && should[0] == '@') {
+		at = should + 1;
+		should = "";
+	}
+
+	/* check rm_so and rm_eo for consistency */
+	if (sub.rm_so > sub.rm_eo || (sub.rm_so == -1 && sub.rm_eo != -1) ||
+				(sub.rm_so != -1 && sub.rm_eo == -1) ||
+				(sub.rm_so != -1 && sub.rm_so < 0) ||
+				(sub.rm_eo != -1 && sub.rm_eo < 0) ) {
+		sprintf(grump, "start %ld end %ld", (long)sub.rm_so,
+							(long)sub.rm_eo);
+		return(grump);
+	}
+
+	/* check for no match */
+	if (sub.rm_so == -1 && should == NULL)
+		return(NULL);
+	if (sub.rm_so == -1)
+		return("did not match");
+
+	/* check for in range */
+	if (sub.rm_eo > strlen(str)) {
+		sprintf(grump, "start %ld end %ld, past end of string",
+					(long)sub.rm_so, (long)sub.rm_eo);
+		return(grump);
+	}
+
+	len = (int)(sub.rm_eo - sub.rm_so);
+	shlen = (int)strlen(should);
+	p = str + sub.rm_so;
+
+	/* check for not supposed to match */
+	if (should == NULL) {
+		sprintf(grump, "matched `%.*s'", len, p);
+		return(grump);
+	}
+
+	/* check for wrong match */
+	if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
+		sprintf(grump, "matched `%.*s' instead", len, p);
+		return(grump);
+	}
+	if (shlen > 0)
+		return(NULL);
+
+	/* check null match in right place */
+	if (at == NULL)
+		return(NULL);
+	shlen = strlen(at);
+	if (shlen == 0)
+		shlen = 1;	/* force check for end-of-string */
+	if (strncmp(p, at, shlen) != 0) {
+		sprintf(grump, "matched null at `%.20s'", p);
+		return(grump);
+	}
+	return(NULL);
+}
+
+/*
+ - eprint - convert error number to name
+ == static char *eprint(int err);
+ */
+static char *
+eprint(err)
+int err;
+{
+	static char epbuf[100];
+	size_t len;
+
+	len = regerror(REG_ITOA|err, (regex_t *)NULL, epbuf, sizeof(epbuf));
+	assert(len <= sizeof(epbuf));
+	return(epbuf);
+}
+
+/*
+ - efind - convert error name to number
+ == static int efind(char *name);
+ */
+static int
+efind(name)
+char *name;
+{
+	static char efbuf[100];
+	size_t n;
+	regex_t re;
+
+	sprintf(efbuf, "REG_%s", name);
+	assert(strlen(efbuf) < sizeof(efbuf));
+	re.re_endp = efbuf;
+	(void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
+	return(atoi(efbuf));
+}

src/regex/mkh

@@ -0,0 +1,76 @@
+#! /bin/sh
+# mkh - pull headers out of C source
+PATH=/bin:/usr/bin ; export PATH
+
+# egrep pattern to pick out marked lines
+egrep='^ =([ 	]|$)'
+
+# Sed program to process marked lines into lines for the header file.
+# The markers have already been removed.  Two things are done here:  removal
+# of backslashed newlines, and some fudging of comments.  The first is done
+# because -o needs to have prototypes on one line to strip them down.
+# Getting comments into the output is tricky; we turn C++-style // comments
+# into /* */ comments, after altering any existing */'s to avoid trouble.
+peel='	/\\$/N
+	/\\\n[ 	]*/s///g
+	/\/\//s;\*/;* /;g
+	/\/\//s;//\(.*\);/*\1 */;'
+
+for a
+do
+	case "$a" in
+	-o)	# old (pre-function-prototype) compiler
+		# add code to comment out argument lists
+		peel="$peel
+			"'/^\([^#\/][^\/]*[a-zA-Z0-9_)]\)(\(.*\))/s;;\1(/*\2*/);'
+		shift
+		;;
+	-b)	# funny Berkeley __P macro
+		peel="$peel
+			"'/^\([^#\/][^\/]*[a-zA-Z0-9_)]\)(\(.*\))/s;;\1 __P((\2));'
+		shift
+		;;
+	-s)	# compiler doesn't like `static foo();'
+		# add code to get rid of the `static'
+		peel="$peel
+			"'/^static[ 	][^\/]*[a-zA-Z0-9_)](.*)/s;static.;;'
+		shift
+		;;
+	-p)	# private declarations
+		egrep='^ ==([ 	]|$)'
+		shift
+		;;
+	-i)	# wrap in #ifndef, argument is name
+		ifndef="$2"
+		shift ; shift
+		;;
+	*)	break
+		;;
+	esac
+done
+
+if test " $ifndef" != " "
+then
+	echo "#ifndef $ifndef"
+	echo "#define	$ifndef	/* never again */"
+fi
+echo "/* ========= begin header generated by $0 ========= */"
+echo '#ifdef __cplusplus'
+echo 'extern "C" {'
+echo '#endif'
+for f
+do
+	echo
+	echo "/* === $f === */"
+	egrep "$egrep" $f | sed 's/^ ==*[ 	]//;s/^ ==*$//' | sed "$peel"
+	echo
+done
+echo '#ifdef __cplusplus'
+echo '}'
+echo '#endif'
+echo "/* ========= end header generated by $0 ========= */"
+if test " $ifndef" != " "
+then
+	echo "#endif"
+fi
+exit 0

src/regex/regerror.c

@@ -0,0 +1,126 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regerror.ih"
+
+/*
+ = #define	REG_OKAY	 0
+ = #define	REG_NOMATCH	 1
+ = #define	REG_BADPAT	 2
+ = #define	REG_ECOLLATE	 3
+ = #define	REG_ECTYPE	 4
+ = #define	REG_EESCAPE	 5
+ = #define	REG_ESUBREG	 6
+ = #define	REG_EBRACK	 7
+ = #define	REG_EPAREN	 8
+ = #define	REG_EBRACE	 9
+ = #define	REG_BADBR	10
+ = #define	REG_ERANGE	11
+ = #define	REG_ESPACE	12
+ = #define	REG_BADRPT	13
+ = #define	REG_EMPTY	14
+ = #define	REG_ASSERT	15
+ = #define	REG_INVARG	16
+ = #define	REG_ATOI	255	// convert name to number (!)
+ = #define	REG_ITOA	0400	// convert number to name (!)
+ */
+static struct rerr {
+	int code;
+	char *name;
+	char *explain;
+} rerrs[] = {
+	REG_OKAY,	"REG_OKAY",	"no errors detected",
+	REG_NOMATCH,	"REG_NOMATCH",	"regexec() failed to match",
+	REG_BADPAT,	"REG_BADPAT",	"invalid regular expression",
+	REG_ECOLLATE,	"REG_ECOLLATE",	"invalid collating element",
+	REG_ECTYPE,	"REG_ECTYPE",	"invalid character class",
+	REG_EESCAPE,	"REG_EESCAPE",	"trailing backslash (\\)",
+	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",	"repetition-operator operand invalid",
+	REG_EMPTY,	"REG_EMPTY",	"empty (sub)expression",
+	REG_ASSERT,	"REG_ASSERT",	"\"can't happen\" -- you found a bug",
+	REG_INVARG,	"REG_INVARG",	"invalid argument to regex routine",
+	-1,		"",		"*** unknown regexp error code ***",
+};
+
+/*
+ - regerror - the interface to error numbers
+ = extern size_t regerror(int, const regex_t *, char *, size_t);
+ */
+/* ARGSUSED */
+size_t
+regerror(errcode, preg, errbuf, errbuf_size)
+int errcode;
+const regex_t *preg;
+char *errbuf;
+size_t errbuf_size;
+{
+	register struct rerr *r;
+	register size_t len;
+	register int target = errcode &~ REG_ITOA;
+	register char *s;
+	char convbuf[50];
+
+	if (errcode == REG_ATOI)
+		s = regatoi(preg, convbuf);
+	else {
+		for (r = rerrs; r->code >= 0; r++)
+			if (r->code == target)
+				break;
+	
+		if (errcode&REG_ITOA) {
+			if (r->code >= 0)
+				(void) strcpy(convbuf, r->name);
+			else
+				sprintf(convbuf, "REG_0x%x", target);
+			assert(strlen(convbuf) < sizeof(convbuf));
+			s = convbuf;
+		} else
+			s = r->explain;
+	}
+
+	len = strlen(s) + 1;
+	if (errbuf_size > 0) {
+		if (errbuf_size > len)
+			(void) strcpy(errbuf, s);
+		else {
+			(void) strncpy(errbuf, s, errbuf_size-1);
+			errbuf[errbuf_size-1] = '\0';
+		}
+	}
+
+	return(len);
+}
+
+/*
+ - regatoi - internal routine to implement REG_ATOI
+ == static char *regatoi(const regex_t *preg, char *localbuf);
+ */
+static char *
+regatoi(preg, localbuf)
+const regex_t *preg;
+char *localbuf;
+{
+	register struct rerr *r;
+
+	for (r = rerrs; r->code >= 0; r++)
+		if (strcmp(r->name, preg->re_endp) == 0)
+			break;
+	if (r->code < 0)
+		return("0");
+
+	sprintf(localbuf, "%d", r->code);
+	return(localbuf);
+}

src/regex/regex.3

@@ -0,0 +1,509 @@
+.TH REGEX 3 "25 Sept 1997"
+.BY "Henry Spencer"
+.de ZR
+.\" one other place knows this name:  the SEE ALSO section
+.IR regex (7) \\$1
+..
+.SH NAME
+regcomp, regexec, regerror, regfree \- regular-expression library
+.SH SYNOPSIS
+.ft B
+.\".na
+#include <sys/types.h>
+.br
+#include <regex.h>
+.HP 10
+int regcomp(regex_t\ *preg, const\ char\ *pattern, int\ cflags);
+.HP
+int\ regexec(const\ regex_t\ *preg, const\ char\ *string,
+size_t\ nmatch, regmatch_t\ pmatch[], int\ eflags);
+.HP
+size_t\ regerror(int\ errcode, const\ regex_t\ *preg,
+char\ *errbuf, size_t\ errbuf_size);
+.HP
+void\ regfree(regex_t\ *preg);
+.\".ad
+.ft
+.SH DESCRIPTION
+These routines implement POSIX 1003.2 regular expressions (``RE''s);
+see
+.ZR .
+.I Regcomp
+compiles an RE written as a string into an internal form,
+.I regexec
+matches that internal form against a string and reports results,
+.I regerror
+transforms error codes from either into human-readable messages,
+and
+.I regfree
+frees any dynamically-allocated storage used by the internal form
+of an RE.
+.PP
+The header
+.I <regex.h>
+declares two structure types,
+.I regex_t
+and
+.IR regmatch_t ,
+the former for compiled internal forms and the latter for match reporting.
+It also declares the four functions,
+a type
+.IR regoff_t ,
+and a number of constants with names starting with ``REG_''.
+.PP
+.I Regcomp
+compiles the regular expression contained in the
+.I pattern
+string,
+subject to the flags in
+.IR cflags ,
+and places the results in the
+.I regex_t
+structure pointed to by
+.IR preg .
+.I Cflags
+is the bitwise OR of zero or more of the following flags:
+.IP REG_EXTENDED \w'REG_EXTENDED'u+2n
+Compile modern (``extended'') REs,
+rather than the obsolete (``basic'') REs that
+are the default.
+.IP REG_BASIC
+This is a synonym for 0,
+provided as a counterpart to REG_EXTENDED to improve readability.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.IP REG_NOSPEC
+Compile with recognition of all special characters turned off.
+All characters are thus considered ordinary,
+so the ``RE'' is a literal string.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+REG_EXTENDED and REG_NOSPEC may not be used
+in the same call to
+.IR regcomp .
+.IP REG_ICASE
+Compile for matching that ignores upper/lower case distinctions.
+See
+.ZR .
+.IP REG_NOSUB
+Compile for matching that need only report success or failure,
+not what was matched.
+.IP REG_NEWLINE
+Compile for newline-sensitive matching.
+By default, newline is a completely ordinary character with no special
+meaning in either REs or strings.
+With this flag,
+`[^' bracket expressions and `.' never match newline,
+a `^' anchor matches the null string after any newline in the string
+in addition to its normal function,
+and the `$' anchor matches the null string before any newline in the
+string in addition to its normal function.
+.IP REG_PEND
+The regular expression ends,
+not at the first NUL,
+but just before the character pointed to by the
+.I re_endp
+member of the structure pointed to by
+.IR preg .
+The
+.I re_endp
+member is of type
+.IR const\ char\ * .
+This flag permits inclusion of NULs in the RE;
+they are considered ordinary characters.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+When successful,
+.I regcomp
+returns 0 and fills in the structure pointed to by
+.IR preg .
+One member of that structure
+(other than
+.IR re_endp )
+is publicized:
+.IR re_nsub ,
+of type
+.IR size_t ,
+contains the number of parenthesized subexpressions within the RE
+(except that the value of this member is undefined if the
+REG_NOSUB flag was used).
+If
+.I regcomp
+fails, it returns a non-zero error code;
+see DIAGNOSTICS.
+.PP
+.I Regexec
+matches the compiled RE pointed to by
+.I preg
+against the
+.IR string ,
+subject to the flags in
+.IR eflags ,
+and reports results using
+.IR nmatch ,
+.IR pmatch ,
+and the returned value.
+The RE must have been compiled by a previous invocation of
+.IR regcomp .
+The compiled form is not altered during execution of
+.IR regexec ,
+so a single compiled RE can be used simultaneously by multiple threads.
+.PP
+By default,
+the NUL-terminated string pointed to by
+.I string
+is considered to be the text of an entire line,
+with the NUL indicating the end of the line.
+(That is,
+any other end-of-line marker is considered to have been removed
+and replaced by the NUL.)
+The
+.I eflags
+argument is the bitwise OR of zero or more of the following flags:
+.IP REG_NOTBOL \w'REG_STARTEND'u+2n
+The first character of
+the string
+is not the beginning of a line, so the `^' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_NOTEOL
+The NUL terminating
+the string
+does not end a line, so the `$' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_STARTEND
+The string is considered to start at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_so\fR
+and to have a terminating NUL located at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_eo\fR
+(there need not actually be a NUL at that location),
+regardless of the value of
+.IR nmatch .
+See below for the definition of
+.IR pmatch
+and
+.IR nmatch .
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Note that a non-zero \fIrm_so\fR does not imply REG_NOTBOL;
+REG_STARTEND affects only the location of the string,
+not how it is matched.
+.PP
+See
+.ZR
+for a discussion of what is matched in situations where an RE or a
+portion thereof could match any of several substrings of
+.IR string .
+.PP
+Normally,
+.I regexec
+returns 0 for success and the non-zero code REG_NOMATCH for failure.
+Other non-zero error codes may be returned in exceptional situations;
+see DIAGNOSTICS.
+.PP
+If REG_NOSUB was specified in the compilation of the RE,
+or if
+.I nmatch
+is 0,
+.I regexec
+ignores the
+.I pmatch
+argument (but see below for the case where REG_STARTEND is specified).
+Otherwise,
+.I pmatch
+points to an array of
+.I nmatch
+structures of type
+.IR regmatch_t .
+Such a structure has at least the members
+.I rm_so
+and
+.IR rm_eo ,
+both of type
+.I regoff_t
+(a signed arithmetic type at least as large as an
+.I off_t
+and a
+.IR ssize_t ),
+containing respectively the offset of the first character of a substring
+and the offset of the first character after the end of the substring.
+Offsets are measured from the beginning of the
+.I string
+argument given to
+.IR regexec .
+An empty substring is denoted by equal offsets,
+both indicating the character following the empty substring.
+.PP
+The 0th member of the
+.I pmatch
+array is filled in to indicate what substring of
+.I string
+was matched by the entire RE.
+Remaining members report what substring was matched by parenthesized
+subexpressions within the RE;
+member
+.I i
+reports subexpression
+.IR i ,
+with subexpressions counted (starting at 1) by the order of their opening
+parentheses in the RE, left to right.
+Unused entries in the array\(emcorresponding either to subexpressions that
+did not participate in the match at all, or to subexpressions that do not
+exist in the RE (that is, \fIi\fR\ > \fIpreg\fR\->\fIre_nsub\fR)\(emhave both
+.I rm_so
+and
+.I rm_eo
+set to \-1.
+If a subexpression participated in the match several times,
+the reported substring is the last one it matched.
+(Note, as an example in particular, that when the RE `(b*)+' matches `bbb',
+the parenthesized subexpression matches the three `b's and then
+an infinite number of empty strings following the last `b',
+so the reported substring is one of the empties.)
+.PP
+If REG_STARTEND is specified,
+.I pmatch
+must point to at least one
+.I regmatch_t
+(even if
+.I nmatch
+is 0 or REG_NOSUB was specified),
+to hold the input offsets for REG_STARTEND.
+Use for output is still entirely controlled by
+.IR nmatch ;
+if
+.I nmatch
+is 0 or REG_NOSUB was specified,
+the value of
+.IR pmatch [0]
+will not be changed by a successful
+.IR regexec .
+.PP
+.I Regerror
+maps a non-zero
+.I errcode
+from either
+.I regcomp
+or
+.I regexec
+to a human-readable, printable message.
+If
+.I preg
+is non-NULL,
+the error code should have arisen from use of
+the
+.I regex_t
+pointed to by
+.IR preg ,
+and if the error code came from
+.IR regcomp ,
+it should have been the result from the most recent
+.I regcomp
+using that
+.IR regex_t .
+.RI ( Regerror
+may be able to supply a more detailed message using information
+from the
+.IR regex_t .)
+.I Regerror
+places the NUL-terminated message into the buffer pointed to by
+.IR errbuf ,
+limiting the length (including the NUL) to at most
+.I errbuf_size
+bytes.
+If the whole message won't fit,
+as much of it as will fit before the terminating NUL is supplied.
+In any case,
+the returned value is the size of buffer needed to hold the whole
+message (including terminating NUL).
+If
+.I errbuf_size
+is 0,
+.I errbuf
+is ignored but the return value is still correct.
+.PP
+If the
+.I errcode
+given to
+.I regerror
+is first ORed with REG_ITOA,
+the ``message'' that results is the printable name of the error code,
+e.g. ``REG_NOMATCH'',
+rather than an explanation thereof.
+If
+.I errcode
+is REG_ATOI,
+then
+.I preg
+shall be non-NULL and the
+.I re_endp
+member of the structure it points to
+must point to the printable name of an error code;
+in this case, the result in
+.I errbuf
+is the decimal digits of
+the numeric value of the error code
+(0 if the name is not recognized).
+REG_ITOA and REG_ATOI are intended primarily as debugging facilities;
+they are extensions,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Be warned also that they are considered experimental and changes are possible.
+.PP
+.I Regfree
+frees any dynamically-allocated storage associated with the compiled RE
+pointed to by
+.IR preg .
+The remaining
+.I regex_t
+is no longer a valid compiled RE
+and the effect of supplying it to
+.I regexec
+or
+.I regerror
+is undefined.
+.PP
+None of these functions references global variables except for tables
+of constants;
+all are safe for use from multiple threads if the arguments are safe.
+.SH IMPLEMENTATION CHOICES
+There are a number of decisions that 1003.2 leaves up to the implementor,
+either by explicitly saying ``undefined'' or by virtue of them being
+forbidden by the RE grammar.
+This implementation treats them as follows.
+.PP
+See
+.ZR
+for a discussion of the definition of case-independent matching.
+.PP
+There is no particular limit on the length of REs,
+except insofar as memory is limited.
+Memory usage is approximately linear in RE size, and largely insensitive
+to RE complexity, except for bounded repetitions.
+See BUGS for one short RE using them
+that will run almost any system out of memory.
+.PP
+A backslashed character other than one specifically given a magic meaning
+by 1003.2 (such magic meanings occur only in obsolete [``basic''] REs)
+is taken as an ordinary character.
+.PP
+Any unmatched [ is a REG_EBRACK error.
+.PP
+Equivalence classes cannot begin or end bracket-expression ranges.
+The endpoint of one range cannot begin another.
+.PP
+RE_DUP_MAX, the limit on repetition counts in bounded repetitions, is 255.
+.PP
+A repetition operator (?, *, +, or bounds) cannot follow another
+repetition operator.
+A repetition operator cannot begin an expression or subexpression
+or follow `^' or `|'.
+.PP
+`|' cannot appear first or last in a (sub)expression or after another `|',
+i.e. an operand of `|' cannot be an empty subexpression.
+An empty parenthesized subexpression, `()', is legal and matches an
+empty (sub)string.
+An empty string is not a legal RE.
+.PP
+A `{' followed by a digit is considered the beginning of bounds for a
+bounded repetition, which must then follow the syntax for bounds.
+A `{' \fInot\fR followed by a digit is considered an ordinary character.
+.PP
+`^' and `$' beginning and ending subexpressions in obsolete (``basic'')
+REs are anchors, not ordinary characters.
+.SH SEE ALSO
+grep(1), regex(7)
+.PP
+POSIX 1003.2, sections 2.8 (Regular Expression Notation)
+and
+B.5 (C Binding for Regular Expression Matching).
+.SH DIAGNOSTICS
+Non-zero error codes from
+.I regcomp
+and
+.I regexec
+include the following:
+.PP
+.nf
+.ta \w'REG_ECOLLATE'u+3n
+REG_NOMATCH	regexec() failed to match
+REG_BADPAT	invalid regular expression
+REG_ECOLLATE	invalid collating element
+REG_ECTYPE	invalid character class
+REG_EESCAPE	\e applied to unescapable character
+REG_ESUBREG	invalid backreference number
+REG_EBRACK	brackets [ ] not balanced
+REG_EPAREN	parentheses ( ) not balanced
+REG_EBRACE	braces { } not balanced
+REG_BADBR	invalid repetition count(s) in { }
+REG_ERANGE	invalid character range in [ ]
+REG_ESPACE	ran out of memory
+REG_BADRPT	?, *, or + operand invalid
+REG_EMPTY	empty (sub)expression
+REG_ASSERT	``can't happen''\(emyou found a bug
+REG_INVARG	invalid argument, e.g. negative-length string
+.fi
+.SH HISTORY
+Written by Henry Spencer,
+henry@zoo.toronto.edu.
+.SH BUGS
+This is an alpha release with known defects.
+Please report problems.
+.PP
+There is one known functionality bug.
+The implementation of internationalization is incomplete:
+the locale is always assumed to be the default one of 1003.2,
+and only the collating elements etc. of that locale are available.
+.PP
+The back-reference code is subtle and doubts linger about its correctness
+in complex cases.
+.PP
+.I Regexec
+performance is poor.
+This will improve with later releases.
+.I Nmatch
+exceeding 0 is expensive;
+.I nmatch
+exceeding 1 is worse.
+.I Regexec
+is largely insensitive to RE complexity \fIexcept\fR that back
+references are massively expensive.
+RE length does matter; in particular, there is a strong speed bonus
+for keeping RE length under about 30 characters,
+with most special characters counting roughly double.
+.PP
+.I Regcomp
+implements bounded repetitions by macro expansion,
+which is costly in time and space if counts are large
+or bounded repetitions are nested.
+An RE like, say,
+`((((a{1,100}){1,100}){1,100}){1,100}){1,100}'
+will (eventually) run almost any existing machine out of swap space.
+.PP
+There are suspected problems with response to obscure error conditions.
+Notably,
+certain kinds of internal overflow,
+produced only by truly enormous REs or by multiply nested bounded repetitions,
+are probably not handled well.
+.PP
+Due to a mistake in 1003.2, things like `a)b' are legal REs because `)' is
+a special character only in the presence of a previous unmatched `('.
+This can't be fixed until the spec is fixed.
+.PP
+The standard's definition of back references is vague.
+For example, does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?
+Until the standard is clarified,
+behavior in such cases should not be relied on.
+.PP
+The implementation of word-boundary matching is a bit of a kludge,
+and bugs may lurk in combinations of word-boundary matching and anchoring.

src/regex/regex.7

@@ -0,0 +1,235 @@
+.TH REGEX 7 "25 Oct 1995"
+.BY "Henry Spencer"
+.SH NAME
+regex \- POSIX 1003.2 regular expressions
+.SH DESCRIPTION
+Regular expressions (``RE''s),
+as defined in POSIX 1003.2, come in two forms:
+modern REs (roughly those of
+.IR egrep ;
+1003.2 calls these ``extended'' REs)
+and obsolete REs (roughly those of
+.IR ed ;
+1003.2 ``basic'' REs).
+Obsolete REs mostly exist for backward compatibility in some old programs;
+they will be discussed at the end.
+1003.2 leaves some aspects of RE syntax and semantics open;
+`\(dg' marks decisions on these aspects that
+may not be fully portable to other 1003.2 implementations.
+.PP
+A (modern) RE is one\(dg or more non-empty\(dg \fIbranches\fR,
+separated by `|'.
+It matches anything that matches one of the branches.
+.PP
+A branch is one\(dg or more \fIpieces\fR, concatenated.
+It matches a match for the first, followed by a match for the second, etc.
+.PP
+A piece is an \fIatom\fR possibly followed
+by a single\(dg `*', `+', `?', or \fIbound\fR.
+An atom followed by `*' matches a sequence of 0 or more matches of the atom.
+An atom followed by `+' matches a sequence of 1 or more matches of the atom.
+An atom followed by `?' matches a sequence of 0 or 1 matches of the atom.
+.PP
+A \fIbound\fR is `{' followed by an unsigned decimal integer,
+possibly followed by `,'
+possibly followed by another unsigned decimal integer,
+always followed by `}'.
+The integers must lie between 0 and RE_DUP_MAX (255\(dg) inclusive,
+and if there are two of them, the first may not exceed the second.
+An atom followed by a bound containing one integer \fIi\fR
+and no comma matches
+a sequence of exactly \fIi\fR matches of the atom.
+An atom followed by a bound
+containing one integer \fIi\fR and a comma matches
+a sequence of \fIi\fR or more matches of the atom.
+An atom followed by a bound
+containing two integers \fIi\fR and \fIj\fR matches
+a sequence of \fIi\fR through \fIj\fR (inclusive) matches of the atom.
+.PP
+An atom is a regular expression enclosed in `()' (matching a match for the
+regular expression),
+an empty set of `()' (matching the null string)\(dg,
+a \fIbracket expression\fR (see below), `.'
+(matching any single character), `^' (matching the null string at the
+beginning of a line), `$' (matching the null string at the
+end of a line), a `\e' followed by one of the characters
+`^.[$()|*+?{\e'
+(matching that character taken as an ordinary character),
+a `\e' followed by any other character\(dg
+(matching that character taken as an ordinary character,
+as if the `\e' had not been present\(dg),
+or a single character with no other significance (matching that character).
+A `{' followed by a character other than a digit is an ordinary
+character, not the beginning of a bound\(dg.
+It is illegal to end an RE with `\e'.
+.PP
+A \fIbracket expression\fR is a list of characters enclosed in `[]'.
+It normally matches any single character from the list (but see below).
+If the list begins with `^',
+it matches any single character
+(but see below) \fInot\fR from the rest of the list.
+If two characters in the list are separated by `\-', this is shorthand
+for the full \fIrange\fR of characters between those two (inclusive) in the
+collating sequence,
+e.g. `[0\-9]' in ASCII matches any decimal digit.
+It is illegal\(dg for two ranges to share an
+endpoint, e.g. `a\-c\-e'.
+Ranges are very collating-sequence-dependent,
+and portable programs should avoid relying on them.
+.PP
+To include a literal `]' in the list, make it the first character
+(following a possible `^').
+To include a literal `\-', make it the first or last character,
+or the second endpoint of a range.
+To use a literal `\-' as the first endpoint of a range,
+enclose it in `[.' and `.]' to make it a collating element (see below).
+With the exception of these and some combinations using `[' (see next
+paragraphs), all other special characters, including `\e', lose their
+special significance within a bracket expression.
+.PP
+Within a bracket expression, a collating element (a character,
+a multi-character sequence that collates as if it were a single character,
+or a collating-sequence name for either)
+enclosed in `[.' and `.]' stands for the
+sequence of characters of that collating element.
+The sequence is a single element of the bracket expression's list.
+A bracket expression containing a multi-character collating element 
+can thus match more than one character,
+e.g. if the collating sequence includes a `ch' collating element,
+then the RE `[[.ch.]]*c' matches the first five characters
+of `chchcc'.
+.PP
+Within a bracket expression, a collating element enclosed in `[=' and
+`=]' is an equivalence class, standing for the sequences of characters
+of all collating elements equivalent to that one, including itself.
+(If there are no other equivalent collating elements,
+the treatment is as if the enclosing delimiters were `[.' and `.]'.)
+For example, if o and \o'o^' are the members of an equivalence class,
+then `[[=o=]]', `[[=\o'o^'=]]', and `[o\o'o^']' are all synonymous.
+An equivalence class may not\(dg be an endpoint
+of a range.
+.PP
+Within a bracket expression, the name of a \fIcharacter class\fR enclosed
+in `[:' and `:]' stands for the list of all characters belonging to that
+class.
+Standard character class names are:
+.PP
+.RS
+.nf
+.ta 3c 6c 9c
+alnum	digit	punct
+alpha	graph	space
+blank	lower	upper
+cntrl	print	xdigit
+.fi
+.RE
+.PP
+These stand for the character classes defined in
+.IR ctype (3).
+A locale may provide others.
+A character class may not be used as an endpoint of a range.
+.PP
+There are two special cases\(dg of bracket expressions:
+the bracket expressions `[[:<:]]' and `[[:>:]]' match the null string at
+the beginning and end of a word respectively.
+A word is defined as a sequence of
+word characters
+which is neither preceded nor followed by
+word characters.
+A word character is an
+.I alnum
+character (as defined by
+.IR ctype (3))
+or an underscore.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+In the event that an RE could match more than one substring of a given
+string,
+the RE matches the one starting earliest in the string.
+If the RE could match more than one substring starting at that point,
+it matches the longest.
+Subexpressions also match the longest possible substrings, subject to
+the constraint that the whole match be as long as possible,
+with subexpressions starting earlier in the RE taking priority over
+ones starting later.
+Note that higher-level subexpressions thus take priority over
+their lower-level component subexpressions.
+.PP
+Match lengths are measured in characters, not collating elements.
+A null string is considered longer than no match at all.
+For example,
+`bb*' matches the three middle characters of `abbbc',
+`(wee|week)(knights|nights)' matches all ten characters of `weeknights',
+when `(.*).*' is matched against `abc' the parenthesized subexpression
+matches all three characters, and
+when `(a*)*' is matched against `bc' both the whole RE and the parenthesized
+subexpression match the null string.
+.PP
+If case-independent matching is specified,
+the effect is much as if all case distinctions had vanished from the
+alphabet.
+When an alphabetic that exists in multiple cases appears as an
+ordinary character outside a bracket expression, it is effectively
+transformed into a bracket expression containing both cases,
+e.g. `x' becomes `[xX]'.
+When it appears inside a bracket expression, all case counterparts
+of it are added to the bracket expression, so that (e.g.) `[x]'
+becomes `[xX]' and `[^x]' becomes `[^xX]'.
+.PP
+No particular limit is imposed on the length of REs\(dg.
+Programs intended to be portable should not employ REs longer
+than 256 bytes,
+as an implementation can refuse to accept such REs and remain
+POSIX-compliant.
+.PP
+Obsolete (``basic'') regular expressions differ in several respects.
+`|', `+', and `?' are ordinary characters and there is no equivalent
+for their functionality.
+The delimiters for bounds are `\e{' and `\e}',
+with `{' and `}' by themselves ordinary characters.
+The parentheses for nested subexpressions are `\e(' and `\e)',
+with `(' and `)' by themselves ordinary characters.
+`^' is an ordinary character except at the beginning of the
+RE or\(dg the beginning of a parenthesized subexpression,
+`$' is an ordinary character except at the end of the
+RE or\(dg the end of a parenthesized subexpression,
+and `*' is an ordinary character if it appears at the beginning of the
+RE or the beginning of a parenthesized subexpression
+(after a possible leading `^').
+Finally, there is one new type of atom, a \fIback reference\fR:
+`\e' followed by a non-zero decimal digit \fId\fR
+matches the same sequence of characters
+matched by the \fId\fRth parenthesized subexpression
+(numbering subexpressions by the positions of their opening parentheses,
+left to right),
+so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
+.SH SEE ALSO
+regex(3)
+.PP
+POSIX 1003.2, section 2.8 (Regular Expression Notation).
+.SH HISTORY
+Written by Henry Spencer, based on the 1003.2 spec.
+.SH BUGS
+Having two kinds of REs is a botch.
+.PP
+The current 1003.2 spec says that `)' is an ordinary character in
+the absence of an unmatched `(';
+this was an unintentional result of a wording error,
+and change is likely.
+Avoid relying on it.
+.PP
+Back references are a dreadful botch,
+posing major problems for efficient implementations.
+They are also somewhat vaguely defined
+(does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?).
+Avoid using them.
+.PP
+1003.2's specification of case-independent matching is vague.
+The ``one case implies all cases'' definition given above
+is current consensus among implementors as to the right interpretation.
+.PP
+The syntax for word boundaries is incredibly ugly.

src/regex/regex2.h

@@ -0,0 +1,134 @@
+/*
+ * First, the stuff that ends up in the outside-world include file
+ = typedef off_t regoff_t;
+ = typedef struct {
+ = 	int re_magic;
+ = 	size_t re_nsub;		// number of parenthesized subexpressions
+ = 	const char *re_endp;	// end pointer for REG_PEND
+ = 	struct re_guts *re_g;	// none of your business :-)
+ = } regex_t;
+ = typedef struct {
+ = 	regoff_t rm_so;		// start of match
+ = 	regoff_t rm_eo;		// end of match
+ = } regmatch_t;
+ */
+/*
+ * internals of regex_t
+ */
+#define	MAGIC1	((('r'^0200)<<8) | 'e')
+
+/*
+ * The internal representation is a *strip*, a sequence of
+ * operators ending with an endmarker.  (Some terminology etc. is a
+ * historical relic of earlier versions which used multiple strips.)
+ * Certain oddities in the representation are there to permit running
+ * the machinery backwards; in particular, any deviation from sequential
+ * flow must be marked at both its source and its destination.  Some
+ * fine points:
+ *
+ * - OPLUS_ and O_PLUS are *inside* the loop they create.
+ * - OQUEST_ and O_QUEST are *outside* the bypass they create.
+ * - OCH_ and O_CH are *outside* the multi-way branch they create, while
+ *   OOR1 and OOR2 are respectively the end and the beginning of one of
+ *   the branches.  Note that there is an implicit OOR2 following OCH_
+ *   and an implicit OOR1 preceding O_CH.
+ *
+ * In state representations, an operator's bit is on to signify a state
+ * immediately *preceding* "execution" of that operator.
+ */
+typedef long sop;		/* strip operator */
+typedef long sopno;
+#define	OPRMASK	0x7c000000
+#define	OPDMASK	0x03ffffff
+#define	OPSHIFT	(26)
+#define	OP(n)	((n)&OPRMASK)
+#define	OPND(n)	((n)&OPDMASK)
+#define	SOP(op, opnd)	((op)|(opnd))
+/* operators			   meaning	operand			*/
+/*						(back, fwd are offsets)	*/
+#define	OEND	(1<<OPSHIFT)	/* endmarker	-			*/
+#define	OCHAR	(2<<OPSHIFT)	/* character	unsigned char		*/
+#define	OBOL	(3<<OPSHIFT)	/* left anchor	-			*/
+#define	OEOL	(4<<OPSHIFT)	/* right anchor	-			*/
+#define	OANY	(5<<OPSHIFT)	/* .		-			*/
+#define	OANYOF	(6<<OPSHIFT)	/* [...]	set number		*/
+#define	OBACK_	(7<<OPSHIFT)	/* begin \d	paren number		*/
+#define	O_BACK	(8<<OPSHIFT)	/* end \d	paren number		*/
+#define	OPLUS_	(9<<OPSHIFT)	/* + prefix	fwd to suffix		*/
+#define	O_PLUS	(10<<OPSHIFT)	/* + suffix	back to prefix		*/
+#define	OQUEST_	(11<<OPSHIFT)	/* ? prefix	fwd to suffix		*/
+#define	O_QUEST	(12<<OPSHIFT)	/* ? suffix	back to prefix		*/
+#define	OLPAREN	(13<<OPSHIFT)	/* (		fwd to )		*/
+#define	ORPAREN	(14<<OPSHIFT)	/* )		back to (		*/
+#define	OCH_	(15<<OPSHIFT)	/* begin choice	fwd to OOR2		*/
+#define	OOR1	(16<<OPSHIFT)	/* | pt. 1	back to OOR1 or OCH_	*/
+#define	OOR2	(17<<OPSHIFT)	/* | pt. 2	fwd to OOR2 or O_CH	*/
+#define	O_CH	(18<<OPSHIFT)	/* end choice	back to OOR1		*/
+#define	OBOW	(19<<OPSHIFT)	/* begin word	-			*/
+#define	OEOW	(20<<OPSHIFT)	/* end word	-			*/
+
+/*
+ * Structure for [] character-set representation.  Character sets are
+ * done as bit vectors, grouped 8 to a byte vector for compactness.
+ * The individual set therefore has both a pointer to the byte vector
+ * and a mask to pick out the relevant bit of each byte.  A hash code
+ * simplifies testing whether two sets could be identical.
+ *
+ * This will get trickier for multicharacter collating elements.  As
+ * preliminary hooks for dealing with such things, we also carry along
+ * a string of multi-character elements, and decide the size of the
+ * vectors at run time.
+ */
+typedef struct {
+	uch *ptr;		/* -> uch [csetsize] */
+	uch mask;		/* bit within array */
+	uch hash;		/* hash code */
+	size_t smultis;
+	char *multis;		/* -> char[smulti]  ab\0cd\0ef\0\0 */
+} cset;
+/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
+#define	CHadd(cs, c)	((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
+#define	CHsub(cs, c)	((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
+#define	CHIN(cs, c)	((cs)->ptr[(uch)(c)] & (cs)->mask)
+#define	MCadd(p, cs, cp)	mcadd(p, cs, cp)	/* regcomp() internal fns */
+#define	MCsub(p, cs, cp)	mcsub(p, cs, cp)
+#define	MCin(p, cs, cp)	mcin(p, cs, cp)
+
+/* stuff for character categories */
+typedef unsigned char cat_t;
+
+/*
+ * main compiled-expression structure
+ */
+struct re_guts {
+	int magic;
+#		define	MAGIC2	((('R'^0200)<<8)|'E')
+	sop *strip;		/* malloced area for strip */
+	int csetsize;		/* number of bits in a cset vector */
+	int ncsets;		/* number of csets in use */
+	cset *sets;		/* -> cset [ncsets] */
+	uch *setbits;		/* -> uch[csetsize][ncsets/CHAR_BIT] */
+	int cflags;		/* copy of regcomp() cflags argument */
+	sopno nstates;		/* = number of sops */
+	sopno firststate;	/* the initial OEND (normally 0) */
+	sopno laststate;	/* the final OEND */
+	int iflags;		/* internal flags */
+#		define	USEBOL	01	/* used ^ */
+#		define	USEEOL	02	/* used $ */
+#		define	BAD	04	/* something wrong */
+	int nbol;		/* number of ^ used */
+	int neol;		/* number of $ used */
+	int ncategories;	/* how many character categories */
+	cat_t *categories;	/* ->catspace[-CHAR_MIN] */
+	char *must;		/* match must contain this string */
+	int mlen;		/* length of must */
+	size_t nsub;		/* copy of re_nsub */
+	int backrefs;		/* does it use back references? */
+	sopno nplus;		/* how deep does it nest +s? */
+	/* catspace must be last */
+	cat_t catspace[1];	/* actually [NC] */
+};
+
+/* misc utilities */
+#define	OUT	(CHAR_MAX+1)	/* a non-character value */
+#define	ISWORD(c)	(isalnum(c) || (c) == '_')

src/regex/regexec.c

@@ -0,0 +1,138 @@
+/*
+ * the outer shell of regexec()
+ *
+ * This file includes engine.c *twice*, after muchos fiddling with the
+ * macros that code uses.  This lets the same code operate on two different
+ * representations for state sets.
+ */
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <ctype.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+
+static int nope = 0;		/* for use in asserts; shuts lint up */
+
+/* macros for manipulating states, small version */
+#define	states	unsigned
+#define	states1	unsigned	/* for later use in regexec() decision */
+#define	CLEAR(v)	((v) = 0)
+#define	SET0(v, n)	((v) &= ~((unsigned)1 << (n)))
+#define	SET1(v, n)	((v) |= (unsigned)1 << (n))
+#define	ISSET(v, n)	((v) & ((unsigned)1 << (n)))
+#define	ASSIGN(d, s)	((d) = (s))
+#define	EQ(a, b)	((a) == (b))
+#define	STATEVARS	int dummy	/* dummy version */
+#define	STATESETUP(m, n)	/* nothing */
+#define	STATETEARDOWN(m)	/* nothing */
+#define	SETUP(v)	((v) = 0)
+#define	onestate	unsigned
+#define	INIT(o, n)	((o) = (unsigned)1 << (n))
+#define	INC(o)	((o) <<= 1)
+#define	ISSTATEIN(v, o)	((v) & (o))
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define	FWD(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) << (n))
+#define	BACK(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) >> (n))
+#define	ISSETBACK(v, n)	((v) & ((unsigned)here >> (n)))
+/* function names */
+#define SNAMES			/* engine.c looks after details */
+
+#include "engine.c"
+
+/* now undo things */
+#undef	states
+#undef	CLEAR
+#undef	SET0
+#undef	SET1
+#undef	ISSET
+#undef	ASSIGN
+#undef	EQ
+#undef	STATEVARS
+#undef	STATESETUP
+#undef	STATETEARDOWN
+#undef	SETUP
+#undef	onestate
+#undef	INIT
+#undef	INC
+#undef	ISSTATEIN
+#undef	FWD
+#undef	BACK
+#undef	ISSETBACK
+#undef	SNAMES
+
+/* macros for manipulating states, large version */
+#define	states	char *
+#define	CLEAR(v)	memset(v, 0, m->g->nstates)
+#define	SET0(v, n)	((v)[n] = 0)
+#define	SET1(v, n)	((v)[n] = 1)
+#define	ISSET(v, n)	((v)[n])
+#define	ASSIGN(d, s)	memcpy(d, s, m->g->nstates)
+#define	EQ(a, b)	(memcmp(a, b, m->g->nstates) == 0)
+#define	STATEVARS	int vn; char *space
+#define	STATESETUP(m, nv)	{ (m)->space = malloc((nv)*(m)->g->nstates); \
+				if ((m)->space == NULL) return(REG_ESPACE); \
+				(m)->vn = 0; }
+#define	STATETEARDOWN(m)	{ free((m)->space); }
+#define	SETUP(v)	((v) = &m->space[m->vn++ * m->g->nstates])
+#define	onestate	int
+#define	INIT(o, n)	((o) = (n))
+#define	INC(o)	((o)++)
+#define	ISSTATEIN(v, o)	((v)[o])
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define	FWD(dst, src, n)	((dst)[here+(n)] |= (src)[here])
+#define	BACK(dst, src, n)	((dst)[here-(n)] |= (src)[here])
+#define	ISSETBACK(v, n)	((v)[here - (n)])
+/* function names */
+#define	LNAMES			/* flag */
+
+#include "engine.c"
+
+/*
+ - regexec - interface for matching
+ = extern int regexec(const regex_t *, const char *, size_t, \
+ =					regmatch_t [], int);
+ = #define	REG_NOTBOL	00001
+ = #define	REG_NOTEOL	00002
+ = #define	REG_STARTEND	00004
+ = #define	REG_TRACE	00400	// tracing of execution
+ = #define	REG_LARGE	01000	// force large representation
+ = #define	REG_BACKR	02000	// force use of backref code
+ *
+ * We put this here so we can exploit knowledge of the state representation
+ * when choosing which matcher to call.  Also, by this point the matchers
+ * have been prototyped.
+ */
+int				/* 0 success, REG_NOMATCH failure */
+regexec(preg, string, nmatch, pmatch, eflags)
+const regex_t *preg;
+const char *string;
+size_t nmatch;
+regmatch_t pmatch[];
+int eflags;
+{
+	register struct re_guts *g = preg->re_g;
+#ifdef REDEBUG
+#	define	GOODFLAGS(f)	(f)
+#else
+#	define	GOODFLAGS(f)	((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
+#endif
+
+	if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
+		return(REG_BADPAT);
+	assert(!(g->iflags&BAD));
+	if (g->iflags&BAD)		/* backstop for no-debug case */
+		return(REG_BADPAT);
+	eflags = GOODFLAGS(eflags);
+
+	if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags&REG_LARGE))
+		return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
+	else
+		return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
+}

src/regex/regfree.c

@@ -0,0 +1,37 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+
+/*
+ - regfree - free everything
+ = extern void regfree(regex_t *);
+ */
+void
+regfree(preg)
+regex_t *preg;
+{
+	register struct re_guts *g;
+
+	if (preg->re_magic != MAGIC1)	/* oops */
+		return;			/* nice to complain, but hard */
+
+	g = preg->re_g;
+	if (g == NULL || g->magic != MAGIC2)	/* oops again */
+		return;
+	preg->re_magic = 0;		/* mark it invalid */
+	g->magic = 0;			/* mark it invalid */
+
+	if (g->strip != NULL)
+		free((char *)g->strip);
+	if (g->sets != NULL)
+		free((char *)g->sets);
+	if (g->setbits != NULL)
+		free((char *)g->setbits);
+	if (g->must != NULL)
+		free(g->must);
+	free((char *)g);
+}

src/regex/split.c

@@ -0,0 +1,316 @@
+#include <stdio.h>
+#include <string.h>
+
+/*
+ - split - divide a string into fields, like awk split()
+ = int split(char *string, char *fields[], int nfields, char *sep);
+ */
+int				/* number of fields, including overflow */
+split(string, fields, nfields, sep)
+char *string;
+char *fields[];			/* list is not NULL-terminated */
+int nfields;			/* number of entries available in fields[] */
+char *sep;			/* "" white, "c" single char, "ab" [ab]+ */
+{
+	register char *p = string;
+	register char c;			/* latest character */
+	register char sepc = sep[0];
+	register char sepc2;
+	register int fn;
+	register char **fp = fields;
+	register char *sepp;
+	register int trimtrail;
+
+	/* white space */
+	if (sepc == '\0') {
+		while ((c = *p++) == ' ' || c == '\t')
+			continue;
+		p--;
+		trimtrail = 1;
+		sep = " \t";	/* note, code below knows this is 2 long */
+		sepc = ' ';
+	} else
+		trimtrail = 0;
+	sepc2 = sep[1];		/* now we can safely pick this up */
+
+	/* catch empties */
+	if (*p == '\0')
+		return(0);
+
+	/* single separator */
+	if (sepc2 == '\0') {
+		fn = nfields;
+		for (;;) {
+			*fp++ = p;
+			fn--;
+			if (fn == 0)
+				break;
+			while ((c = *p++) != sepc)
+				if (c == '\0')
+					return(nfields - fn);
+			*(p-1) = '\0';
+		}
+		/* we have overflowed the fields vector -- just count them */
+		fn = nfields;
+		for (;;) {
+			while ((c = *p++) != sepc)
+				if (c == '\0')
+					return(fn);
+			fn++;
+		}
+		/* not reached */
+	}
+
+	/* two separators */
+	if (sep[2] == '\0') {
+		fn = nfields;
+		for (;;) {
+			*fp++ = p;
+			fn--;
+			while ((c = *p++) != sepc && c != sepc2)
+				if (c == '\0') {
+					if (trimtrail && **(fp-1) == '\0')
+						fn++;
+					return(nfields - fn);
+				}
+			if (fn == 0)
+				break;
+			*(p-1) = '\0';
+			while ((c = *p++) == sepc || c == sepc2)
+				continue;
+			p--;
+		}
+		/* we have overflowed the fields vector -- just count them */
+		fn = nfields;
+		while (c != '\0') {
+			while ((c = *p++) == sepc || c == sepc2)
+				continue;
+			p--;
+			fn++;
+			while ((c = *p++) != '\0' && c != sepc && c != sepc2)
+				continue;
+		}
+		/* might have to trim trailing white space */
+		if (trimtrail) {
+			p--;
+			while ((c = *--p) == sepc || c == sepc2)
+				continue;
+			p++;
+			if (*p != '\0') {
+				if (fn == nfields+1)
+					*p = '\0';
+				fn--;
+			}
+		}
+		return(fn);
+	}
+
+	/* n separators */
+	fn = 0;
+	for (;;) {
+		if (fn < nfields)
+			*fp++ = p;
+		fn++;
+		for (;;) {
+			c = *p++;
+			if (c == '\0')
+				return(fn);
+			sepp = sep;
+			while ((sepc = *sepp++) != '\0' && sepc != c)
+				continue;
+			if (sepc != '\0')	/* it was a separator */
+				break;
+		}
+		if (fn < nfields)
+			*(p-1) = '\0';
+		for (;;) {
+			c = *p++;
+			sepp = sep;
+			while ((sepc = *sepp++) != '\0' && sepc != c)
+				continue;
+			if (sepc == '\0')	/* it wasn't a separator */
+				break;
+		}
+		p--;
+	}
+
+	/* not reached */
+}
+
+#ifdef TEST_SPLIT
+
+
+/*
+ * test program
+ * pgm		runs regression
+ * pgm sep	splits stdin lines by sep
+ * pgm str sep	splits str by sep
+ * pgm str sep n	splits str by sep n times
+ */
+int
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	char buf[512];
+	register int n;
+#	define	MNF	10
+	char *fields[MNF];
+
+	if (argc > 4)
+		for (n = atoi(argv[3]); n > 0; n--) {
+			(void) strcpy(buf, argv[1]);
+		}
+	else if (argc > 3)
+		for (n = atoi(argv[3]); n > 0; n--) {
+			(void) strcpy(buf, argv[1]);
+			(void) split(buf, fields, MNF, argv[2]);
+		}
+	else if (argc > 2)
+		dosplit(argv[1], argv[2]);
+	else if (argc > 1)
+		while (fgets(buf, sizeof(buf), stdin) != NULL) {
+			buf[strlen(buf)-1] = '\0';	/* stomp newline */
+			dosplit(buf, argv[1]);
+		}
+	else
+		regress();
+
+	exit(0);
+}
+
+dosplit(string, seps)
+char *string;
+char *seps;
+{
+#	define	NF	5
+	char *fields[NF];
+	register int nf;
+
+	nf = split(string, fields, NF, seps);
+	print(nf, NF, fields);
+}
+
+print(nf, nfp, fields)
+int nf;
+int nfp;
+char *fields[];
+{
+	register int fn;
+	register int bound;
+
+	bound = (nf > nfp) ? nfp : nf;
+	printf("%d:\t", nf);
+	for (fn = 0; fn < bound; fn++)
+		printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
+}
+
+#define	RNF	5		/* some table entries know this */
+struct {
+	char *str;
+	char *seps;
+	int nf;
+	char *fi[RNF];
+} tests[] = {
+	"",		" ",	0,	{ "" },
+	" ",		" ",	2,	{ "", "" },
+	"x",		" ",	1,	{ "x" },
+	"xy",		" ",	1,	{ "xy" },
+	"x y",		" ",	2,	{ "x", "y" },
+	"abc def  g ",	" ",	5,	{ "abc", "def", "", "g", "" },
+	"  a bcd",	" ",	4,	{ "", "", "a", "bcd" },
+	"a b c d e f",	" ",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d ",	" ",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		" _",	0,	{ "" },
+	" ",		" _",	2,	{ "", "" },
+	"x",		" _",	1,	{ "x" },
+	"x y",		" _",	2,	{ "x", "y" },
+	"ab _ cd",	" _",	2,	{ "ab", "cd" },
+	" a_b  c ",	" _",	5,	{ "", "a", "b", "c", "" },
+	"a b c_d e f",	" _",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d ",	" _",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		" _~",	0,	{ "" },
+	" ",		" _~",	2,	{ "", "" },
+	"x",		" _~",	1,	{ "x" },
+	"x y",		" _~",	2,	{ "x", "y" },
+	"ab _~ cd",	" _~",	2,	{ "ab", "cd" },
+	" a_b  c~",	" _~",	5,	{ "", "a", "b", "c", "" },
+	"a b_c d~e f",	" _~",	6,	{ "a", "b", "c", "d", "e f" },
+	"~a b c d ",	" _~",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		" _~-",	0,	{ "" },
+	" ",		" _~-",	2,	{ "", "" },
+	"x",		" _~-",	1,	{ "x" },
+	"x y",		" _~-",	2,	{ "x", "y" },
+	"ab _~- cd",	" _~-",	2,	{ "ab", "cd" },
+	" a_b  c~",	" _~-",	5,	{ "", "a", "b", "c", "" },
+	"a b_c-d~e f",	" _~-",	6,	{ "a", "b", "c", "d", "e f" },
+	"~a-b c d ",	" _~-",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		"  ",	0,	{ "" },
+	" ",		"  ",	2,	{ "", "" },
+	"x",		"  ",	1,	{ "x" },
+	"xy",		"  ",	1,	{ "xy" },
+	"x y",		"  ",	2,	{ "x", "y" },
+	"abc def  g ",	"  ",	4,	{ "abc", "def", "g", "" },
+	"  a bcd",	"  ",	3,	{ "", "a", "bcd" },
+	"a b c d e f",	"  ",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d ",	"  ",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		"",	0,	{ "" },
+	" ",		"",	0,	{ "" },
+	"x",		"",	1,	{ "x" },
+	"xy",		"",	1,	{ "xy" },
+	"x y",		"",	2,	{ "x", "y" },
+	"abc def  g ",	"",	3,	{ "abc", "def", "g" },
+	"\t a bcd",	"",	2,	{ "a", "bcd" },
+	"  a \tb\t c ",	"",	3,	{ "a", "b", "c" },
+	"a b c d e ",	"",	5,	{ "a", "b", "c", "d", "e" },
+	"a b\tc d e f",	"",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d e f ",	"",	6,	{ "a", "b", "c", "d", "e f " },
+
+	NULL,		NULL,	0,	{ NULL },
+};
+
+regress()
+{
+	char buf[512];
+	register int n;
+	char *fields[RNF+1];
+	register int nf;
+	register int i;
+	register int printit;
+	register char *f;
+
+	for (n = 0; tests[n].str != NULL; n++) {
+		(void) strcpy(buf, tests[n].str);
+		fields[RNF] = NULL;
+		nf = split(buf, fields, RNF, tests[n].seps);
+		printit = 0;
+		if (nf != tests[n].nf) {
+			printf("split `%s' by `%s' gave %d fields, not %d\n",
+				tests[n].str, tests[n].seps, nf, tests[n].nf);
+			printit = 1;
+		} else if (fields[RNF] != NULL) {
+			printf("split() went beyond array end\n");
+			printit = 1;
+		} else {
+			for (i = 0; i < nf && i < RNF; i++) {
+				f = fields[i];
+				if (f == NULL)
+					f = "(NULL)";
+				if (strcmp(f, tests[n].fi[i]) != 0) {
+					printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
+						tests[n].str, tests[n].seps,
+						i, fields[i], tests[n].fi[i]);
+					printit = 1;
+				}
+			}
+		}
+		if (printit)
+			print(nf, RNF, fields);
+	}
+}
+#endif

src/regex/tests

@@ -0,0 +1,477 @@
+# regular expression test set
+# Lines are at least three fields, separated by one or more tabs.  "" stands
+# for an empty field.  First field is an RE.  Second field is flags.  If
+# C flag given, regcomp() is expected to fail, and the third field is the
+# error name (minus the leading REG_).
+#
+# Otherwise it is expected to succeed, and the third field is the string to
+# try matching it against.  If there is no fourth field, the match is
+# expected to fail.  If there is a fourth field, it is the substring that
+# the RE is expected to match.  If there is a fifth field, it is a comma-
+# separated list of what the subexpressions should match, with - indicating
+# no match for that one.  In both the fourth and fifth fields, a (sub)field
+# starting with @ indicates that the (sub)expression is expected to match
+# a null string followed by the stuff after the @; this provides a way to
+# test where null strings match.  The character `N' in REs and strings
+# is newline, `S' is space, `T' is tab, `Z' is NUL.
+#
+# The full list of flags:
+#	-	placeholder, does nothing
+#	b	RE is a BRE, not an ERE
+#	&	try it as both an ERE and a BRE
+#	C	regcomp() error expected, third field is error name
+#	i	REG_ICASE
+#	m	("mundane") REG_NOSPEC
+#	s	REG_NOSUB (not really testable)
+#	n	REG_NEWLINE
+#	^	REG_NOTBOL
+#	$	REG_NOTEOL
+#	#	REG_STARTEND (see below)
+#	p	REG_PEND
+#
+# For REG_STARTEND, the start/end offsets are those of the substring
+# enclosed in ().
+
+# basics
+a		&	a	a
+abc		&	abc	abc
+abc|de		-	abc	abc
+a|b|c		-	abc	a
+
+# parentheses and perversions thereof
+a(b)c		-	abc	abc
+a\(b\)c		b	abc	abc
+a(		C	EPAREN
+a(		b	a(	a(
+a\(		-	a(	a(
+a\(		bC	EPAREN
+a\(b		bC	EPAREN
+a(b		C	EPAREN
+a(b		b	a(b	a(b
+# gag me with a right parenthesis -- 1003.2 goofed here (my fault, partly)
+a)		-	a)	a)
+)		-	)	)
+# end gagging (in a just world, those *should* give EPAREN)
+a)		b	a)	a)
+a\)		bC	EPAREN
+\)		bC	EPAREN
+a()b		-	ab	ab
+a\(\)b		b	ab	ab
+
+# anchoring and REG_NEWLINE
+^abc$		&	abc	abc
+a^b		-	a^b
+a^b		b	a^b	a^b
+a$b		-	a$b
+a$b		b	a$b	a$b
+^		&	abc	@abc
+$		&	abc	@
+^$		&	""	@
+$^		-	""	@
+\($\)\(^\)	b	""	@
+# stop retching, those are legitimate (although disgusting)
+^^		-	""	@
+$$		-	""	@
+b$		&	abNc
+b$		&n	abNc	b
+^b$		&	aNbNc
+^b$		&n	aNbNc	b
+^$		&n	aNNb	@Nb
+^$		n	abc
+^$		n	abcN	@
+$^		n	aNNb	@Nb
+\($\)\(^\)	bn	aNNb	@Nb
+^^		n^	aNNb	@Nb
+$$		n	aNNb	@NN
+^a		^	a
+a$		$	a
+^a		^n	aNb
+^b		^n	aNb	b
+a$		$n	bNa
+b$		$n	bNa	b
+a*(^b$)c*	-	b	b
+a*\(^b$\)c*	b	b	b
+
+# certain syntax errors and non-errors
+|		C	EMPTY
+|		b	|	|
+*		C	BADRPT
+*		b	*	*
++		C	BADRPT
+?		C	BADRPT
+""		&C	EMPTY
+()		-	abc	@abc
+\(\)		b	abc	@abc
+a||b		C	EMPTY
+|ab		C	EMPTY
+ab|		C	EMPTY
+(|a)b		C	EMPTY
+(a|)b		C	EMPTY
+(*a)		C	BADRPT
+(+a)		C	BADRPT
+(?a)		C	BADRPT
+({1}a)		C	BADRPT
+\(\{1\}a\)	bC	BADRPT
+(a|*b)		C	BADRPT
+(a|+b)		C	BADRPT
+(a|?b)		C	BADRPT
+(a|{1}b)	C	BADRPT
+^*		C	BADRPT
+^*		b	*	*
+^+		C	BADRPT
+^?		C	BADRPT
+^{1}		C	BADRPT
+^\{1\}		bC	BADRPT
+
+# metacharacters, backslashes
+a.c		&	abc	abc
+a[bc]d		&	abd	abd
+a\*c		&	a*c	a*c
+a\\b		&	a\b	a\b
+a\\\*b		&	a\*b	a\*b
+a\bc		&	abc	abc
+a\		&C	EESCAPE
+a\\bc		&	a\bc	a\bc
+\{		bC	BADRPT
+a\[b		&	a[b	a[b
+a[b		&C	EBRACK
+# trailing $ is a peculiar special case for the BRE code
+a$		&	a	a
+a$		&	a$
+a\$		&	a
+a\$		&	a$	a$
+a\\$		&	a
+a\\$		&	a$
+a\\$		&	a\$
+a\\$		&	a\	a\
+
+# back references, ugh
+a\(b\)\2c	bC	ESUBREG
+a\(b\1\)c	bC	ESUBREG
+a\(b*\)c\1d	b	abbcbbd	abbcbbd	bb
+a\(b*\)c\1d	b	abbcbd
+a\(b*\)c\1d	b	abbcbbbd
+^\(.\)\1	b	abc
+a\([bc]\)\1d	b	abcdabbd	abbd	b
+a\(\([bc]\)\2\)*d	b	abbccd	abbccd
+a\(\([bc]\)\2\)*d	b	abbcbd
+# actually, this next one probably ought to fail, but the spec is unclear
+a\(\(b\)*\2\)*d		b	abbbd	abbbd
+# here is a case that no NFA implementation does right
+\(ab*\)[ab]*\1	b	ababaaa	ababaaa	a
+# check out normal matching in the presence of back refs
+\(a\)\1bcd	b	aabcd	aabcd
+\(a\)\1bc*d	b	aabcd	aabcd
+\(a\)\1bc*d	b	aabd	aabd
+\(a\)\1bc*d	b	aabcccd	aabcccd
+\(a\)\1bc*[ce]d	b	aabcccd	aabcccd
+^\(a\)\1b\(c\)*cd$	b	aabcccd	aabcccd
+
+# ordinary repetitions
+ab*c		&	abc	abc
+ab+c		-	abc	abc
+ab?c		-	abc	abc
+a\(*\)b		b	a*b	a*b
+a\(**\)b	b	ab	ab
+a\(***\)b	bC	BADRPT
+*a		b	*a	*a
+**a		b	a	a
+***a		bC	BADRPT
+
+# the dreaded bounded repetitions
+{		&	{	{
+{abc		&	{abc	{abc
+{1		C	BADRPT
+{1}		C	BADRPT
+a{b		&	a{b	a{b
+a{1}b		-	ab	ab
+a\{1\}b		b	ab	ab
+a{1,}b		-	ab	ab
+a\{1,\}b	b	ab	ab
+a{1,2}b		-	aab	aab
+a\{1,2\}b	b	aab	aab
+a{1		C	EBRACE
+a\{1		bC	EBRACE
+a{1a		C	EBRACE
+a\{1a		bC	EBRACE
+a{1a}		C	BADBR
+a\{1a\}		bC	BADBR
+a{,2}		-	a{,2}	a{,2}
+a\{,2\}		bC	BADBR
+a{,}		-	a{,}	a{,}
+a\{,\}		bC	BADBR
+a{1,x}		C	BADBR
+a\{1,x\}	bC	BADBR
+a{1,x		C	EBRACE
+a\{1,x		bC	EBRACE
+a{300}		C	BADBR
+a\{300\}	bC	BADBR
+a{1,0}		C	BADBR
+a\{1,0\}	bC	BADBR
+ab{0,0}c	-	abcac	ac
+ab\{0,0\}c	b	abcac	ac
+ab{0,1}c	-	abcac	abc
+ab\{0,1\}c	b	abcac	abc
+ab{0,3}c	-	abbcac	abbc
+ab\{0,3\}c	b	abbcac	abbc
+ab{1,1}c	-	acabc	abc
+ab\{1,1\}c	b	acabc	abc
+ab{1,3}c	-	acabc	abc
+ab\{1,3\}c	b	acabc	abc
+ab{2,2}c	-	abcabbc	abbc
+ab\{2,2\}c	b	abcabbc	abbc
+ab{2,4}c	-	abcabbc	abbc
+ab\{2,4\}c	b	abcabbc	abbc
+((a{1,10}){1,10}){1,10}	-	a	a	a,a
+
+# multiple repetitions
+a**		&C	BADRPT
+a++		C	BADRPT
+a??		C	BADRPT
+a*+		C	BADRPT
+a*?		C	BADRPT
+a+*		C	BADRPT
+a+?		C	BADRPT
+a?*		C	BADRPT
+a?+		C	BADRPT
+a{1}{1}		C	BADRPT
+a*{1}		C	BADRPT
+a+{1}		C	BADRPT
+a?{1}		C	BADRPT
+a{1}*		C	BADRPT
+a{1}+		C	BADRPT
+a{1}?		C	BADRPT
+a*{b}		-	a{b}	a{b}
+a\{1\}\{1\}	bC	BADRPT
+a*\{1\}		bC	BADRPT
+a\{1\}*		bC	BADRPT
+
+# brackets, and numerous perversions thereof
+a[b]c		&	abc	abc
+a[ab]c		&	abc	abc
+a[^ab]c		&	adc	adc
+a[]b]c		&	a]c	a]c
+a[[b]c		&	a[c	a[c
+a[-b]c		&	a-c	a-c
+a[^]b]c		&	adc	adc
+a[^-b]c		&	adc	adc
+a[b-]c		&	a-c	a-c
+a[b		&C	EBRACK
+a[]		&C	EBRACK
+a[1-3]c		&	a2c	a2c
+a[3-1]c		&C	ERANGE
+a[1-3-5]c	&C	ERANGE
+a[[.-.]--]c	&	a-c	a-c
+a[1-		&C	ERANGE
+a[[.		&C	EBRACK
+a[[.x		&C	EBRACK
+a[[.x.		&C	EBRACK
+a[[.x.]		&C	EBRACK
+a[[.x.]]	&	ax	ax
+a[[.x,.]]	&C	ECOLLATE
+a[[.one.]]b	&	a1b	a1b
+a[[.notdef.]]b	&C	ECOLLATE
+a[[.].]]b	&	a]b	a]b
+a[[:alpha:]]c	&	abc	abc
+a[[:notdef:]]c	&C	ECTYPE
+a[[:		&C	EBRACK
+a[[:alpha	&C	EBRACK
+a[[:alpha:]	&C	EBRACK
+a[[:alpha,:]	&C	ECTYPE
+a[[:]:]]b	&C	ECTYPE
+a[[:-:]]b	&C	ECTYPE
+a[[:alph:]]	&C	ECTYPE
+a[[:alphabet:]]	&C	ECTYPE
+[[:alnum:]]+	-	-%@a0X-	a0X
+[[:alpha:]]+	-	-%@aX0-	aX
+[[:blank:]]+	-	aSSTb	SST
+[[:cntrl:]]+	-	aNTb	NT
+[[:digit:]]+	-	a019b	019
+[[:graph:]]+	-	Sa%bS	a%b
+[[:lower:]]+	-	AabC	ab
+[[:print:]]+	-	NaSbN	aSb
+[[:punct:]]+	-	S%-&T	%-&
+[[:space:]]+	-	aSNTb	SNT
+[[:upper:]]+	-	aBCd	BC
+[[:xdigit:]]+	-	p0f3Cq	0f3C
+a[[=b=]]c	&	abc	abc
+a[[=		&C	EBRACK
+a[[=b		&C	EBRACK
+a[[=b=		&C	EBRACK
+a[[=b=]		&C	EBRACK
+a[[=b,=]]	&C	ECOLLATE
+a[[=one=]]b	&	a1b	a1b
+
+# complexities
+a(((b)))c	-	abc	abc
+a(b|(c))d	-	abd	abd
+a(b*|c)d	-	abbd	abbd
+# just gotta have one DFA-buster, of course
+a[ab]{20}	-	aaaaabaaaabaaaabaaaab	aaaaabaaaabaaaabaaaab
+# and an inline expansion in case somebody gets tricky
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab]	-	aaaaabaaaabaaaabaaaab	aaaaabaaaabaaaabaaaab
+# and in case somebody just slips in an NFA...
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night)	-	aaaaabaaaabaaaabaaaabweeknights	aaaaabaaaabaaaabaaaabweeknights
+# fish for anomalies as the number of states passes 32
+12345678901234567890123456789	-	a12345678901234567890123456789b	12345678901234567890123456789
+123456789012345678901234567890	-	a123456789012345678901234567890b	123456789012345678901234567890
+1234567890123456789012345678901	-	a1234567890123456789012345678901b	1234567890123456789012345678901
+12345678901234567890123456789012	-	a12345678901234567890123456789012b	12345678901234567890123456789012
+123456789012345678901234567890123	-	a123456789012345678901234567890123b	123456789012345678901234567890123
+# and one really big one, beyond any plausible word width
+1234567890123456789012345678901234567890123456789012345678901234567890	-	a1234567890123456789012345678901234567890123456789012345678901234567890b	1234567890123456789012345678901234567890123456789012345678901234567890
+# fish for problems as brackets go past 8
+[ab][cd][ef][gh][ij][kl][mn]	-	xacegikmoq	acegikm
+[ab][cd][ef][gh][ij][kl][mn][op]	-	xacegikmoq	acegikmo
+[ab][cd][ef][gh][ij][kl][mn][op][qr]	-	xacegikmoqy	acegikmoq
+[ab][cd][ef][gh][ij][kl][mn][op][q]	-	xacegikmoqy	acegikmoq
+
+# subtleties of matching
+abc		&	xabcy	abc
+a\(b\)?c\1d	b	acd
+aBc		i	Abc	Abc
+a[Bc]*d		i	abBCcd	abBCcd
+0[[:upper:]]1	&i	0a1	0a1
+0[[:lower:]]1	&i	0A1	0A1
+a[^b]c		&i	abc
+a[^b]c		&i	aBc
+a[^b]c		&i	adc	adc
+[a]b[c]		-	abc	abc
+[a]b[a]		-	aba	aba
+[abc]b[abc]	-	abc	abc
+[abc]b[abd]	-	abd	abd
+a(b?c)+d	-	accd	accd
+(wee|week)(knights|night)	-	weeknights	weeknights
+(we|wee|week|frob)(knights|night|day)	-	weeknights	weeknights
+a[bc]d		-	xyzaaabcaababdacd	abd
+a[ab]c		-	aaabc	abc
+abc		s	abc	abc
+a*		&	b	@b
+
+# Let's have some fun -- try to match a C comment.
+# first the obvious, which looks okay at first glance...
+/\*.*\*/	-	/*x*/	/*x*/
+# but...
+/\*.*\*/	-	/*x*/y/*z*/	/*x*/y/*z*/
+# okay, we must not match */ inside; try to do that...
+/\*([^*]|\*[^/])*\*/	-	/*x*/	/*x*/
+/\*([^*]|\*[^/])*\*/	-	/*x*/y/*z*/	/*x*/
+# but...
+/\*([^*]|\*[^/])*\*/	-	/*x**/y/*z*/	/*x**/y/*z*/
+# and a still fancier version, which does it right (I think)...
+/\*([^*]|\*+[^*/])*\*+/	-	/*x*/	/*x*/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x*/y/*z*/	/*x*/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x**/y/*z*/	/*x**/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x****/y/*z*/	/*x****/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x**x*/y/*z*/	/*x**x*/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x***x/y/*z*/	/*x***x/y/*z*/
+
+# subexpressions
+.*		-	abc	abc	-
+a(b)(c)d	-	abcd	abcd	b,c
+a(((b)))c	-	abc	abc	b,b,b
+a(b|(c))d	-	abd	abd	b,-
+a(b*|c|e)d	-	abbd	abbd	bb
+a(b*|c|e)d	-	acd	acd	c
+a(b*|c|e)d	-	ad	ad	@d
+a(b?)c		-	abc	abc	b
+a(b?)c		-	ac	ac	@c
+a(b+)c		-	abc	abc	b
+a(b+)c		-	abbbc	abbbc	bbb
+a(b*)c		-	ac	ac	@c
+(a|ab)(bc([de]+)f|cde)	-	abcdef	abcdef	a,bcdef,de
+# the regression tester only asks for 9 subexpressions
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)k	-	abcdefghijk	abcdefghijk	b,c,d,e,f,g,h,i,j
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)l	-	abcdefghijkl	abcdefghijkl	b,c,d,e,f,g,h,i,j,k
+a([bc]?)c	-	abc	abc	b
+a([bc]?)c	-	ac	ac	@c
+a([bc]+)c	-	abc	abc	b
+a([bc]+)c	-	abcc	abcc	bc
+a([bc]+)bc	-	abcbc	abcbc	bc
+a(bb+|b)b	-	abb	abb	b
+a(bbb+|bb+|b)b	-	abb	abb	b
+a(bbb+|bb+|b)b	-	abbb	abbb	bb
+a(bbb+|bb+|b)bb	-	abbb	abbb	b
+(.*).*		-	abcdef	abcdef	abcdef
+(a*)*		-	bc	@b	@b
+
+# do we get the right subexpression when it is used more than once?
+a(b|c)*d	-	ad	ad	-
+a(b|c)*d	-	abcd	abcd	c
+a(b|c)+d	-	abd	abd	b
+a(b|c)+d	-	abcd	abcd	c
+a(b|c?)+d	-	ad	ad	@d
+a(b|c?)+d	-	abcd	abcd	@d
+a(b|c){0,0}d	-	ad	ad	-
+a(b|c){0,1}d	-	ad	ad	-
+a(b|c){0,1}d	-	abd	abd	b
+a(b|c){0,2}d	-	ad	ad	-
+a(b|c){0,2}d	-	abcd	abcd	c
+a(b|c){0,}d	-	ad	ad	-
+a(b|c){0,}d	-	abcd	abcd	c
+a(b|c){1,1}d	-	abd	abd	b
+a(b|c){1,1}d	-	acd	acd	c
+a(b|c){1,2}d	-	abd	abd	b
+a(b|c){1,2}d	-	abcd	abcd	c
+a(b|c){1,}d	-	abd	abd	b
+a(b|c){1,}d	-	abcd	abcd	c
+a(b|c){2,2}d	-	acbd	acbd	b
+a(b|c){2,2}d	-	abcd	abcd	c
+a(b|c){2,4}d	-	abcd	abcd	c
+a(b|c){2,4}d	-	abcbd	abcbd	b
+a(b|c){2,4}d	-	abcbcd	abcbcd	c
+a(b|c){2,}d	-	abcd	abcd	c
+a(b|c){2,}d	-	abcbd	abcbd	b
+a(b+|((c)*))+d	-	abd	abd	@d,@d,-
+a(b+|((c)*))+d	-	abcd	abcd	@d,@d,-
+
+# check out the STARTEND option
+[abc]		&#	a(b)c	b
+[abc]		&#	a(d)c
+[abc]		&#	a(bc)d	b
+[abc]		&#	a(dc)d	c
+.		&#	a()c
+b.*c		&#	b(bc)c	bc
+b.*		&#	b(bc)c	bc
+.*c		&#	b(bc)c	bc
+
+# plain strings, with the NOSPEC flag
+abc		m	abc	abc
+abc		m	xabcy	abc
+abc		m	xyz
+a*b		m	aba*b	a*b
+a*b		m	ab
+""		mC	EMPTY
+
+# cases involving NULs
+aZb		&	a	a
+aZb		&p	a
+aZb		&p#	(aZb)	aZb
+aZ*b		&p#	(ab)	ab
+a.b		&#	(aZb)	aZb
+a.*		&#	(aZb)c	aZb
+
+# word boundaries (ick)
+[[:<:]]a	&	a	a
+[[:<:]]a	&	ba
+[[:<:]]a	&	-a	a
+a[[:>:]]	&	a	a
+a[[:>:]]	&	ab
+a[[:>:]]	&	a-	a
+[[:<:]]a.c[[:>:]]	&	axcd-dayc-dazce-abc	abc
+[[:<:]]a.c[[:>:]]	&	axcd-dayc-dazce-abc-q	abc
+[[:<:]]a.c[[:>:]]	&	axc-dayc-dazce-abc	axc
+[[:<:]]b.c[[:>:]]	&	a_bxc-byc_d-bzc-q	bzc
+[[:<:]].x..[[:>:]]	&	y_xa_-_xb_y-_xc_-axdc	_xc_
+[[:<:]]a_b[[:>:]]	&	x_a_b
+
+# past problems, and suspected problems
+(A[1])|(A[2])|(A[3])|(A[4])|(A[5])|(A[6])|(A[7])|(A[8])|(A[9])|(A[A])	-	A1	A1
+abcdefghijklmnop	i	abcdefghijklmnop	abcdefghijklmnop
+abcdefghijklmnopqrstuv	i	abcdefghijklmnopqrstuv	abcdefghijklmnopqrstuv
+(ALAK)|(ALT[AB])|(CC[123]1)|(CM[123]1)|(GAMC)|(LC[23][EO ])|(SEM[1234])|(SL[ES][12])|(SLWW)|(SLF )|(SLDT)|(VWH[12])|(WH[34][EW])|(WP1[ESN])	-	CC11	CC11
+CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a	-	CC11	CC11
+Char \([a-z0-9_]*\)\[.*	b	Char xyz[k	Char xyz[k	xyz
+a?b	-	ab	ab
+-\{0,1\}[0-9]*$	b	-5	-5
+a*a*a*a*a*a*a*	&	aaaaaa	aaaaaa

src/regex/utils.h

@@ -0,0 +1,22 @@
+/* utility definitions */
+#ifdef _POSIX2_RE_DUP_MAX
+#define	DUPMAX	_POSIX2_RE_DUP_MAX
+#else
+#define	DUPMAX	255
+#endif
+#define	INFINITY	(DUPMAX + 1)
+#define	NC		(CHAR_MAX - CHAR_MIN + 1)
+typedef unsigned char uch;
+
+/* switch off assertions (if not already off) if no REDEBUG */
+#ifndef REDEBUG
+#ifndef NDEBUG
+#define	NDEBUG	/* no assertions please */
+#endif
+#endif
+#include <assert.h>
+
+/* for old systems with bcopy() but no memmove() */
+#ifdef USEBCOPY
+#define	memmove(d, s, c)	bcopy(s, d, c)
+#endif

wxPython/.cvsignore

@@ -1,8 +0,0 @@
-.emacs.desktop
-MANIFEST
-build
-build.local
-dist
-licence
-temp
-update.log

wxPython/BUILD.unix.txt

@@ -1,271 +0,0 @@
-Building wxPython on Unix or Unix-like Systems
-----------------------------------------------
-
-The basic steps for building wxPython for Unix or Unix-like systems
-are:
-
-     1. Compile and/or install glib and gtk+
-     2. Compile and/or install wxGTK
-     3. Compile and install wxPython
-
-We'll go into more detail of each of these steps below, but first a
-few bits of background information on tools.
-
-I use a tool called SWIG (http://www.swig.org) to help generate the
-C++ sources used in the wxPython extension module.  However you don't
-need to have SWIG unless you want to modify the *.i files.  If you do
-you'll want to have version 1.1-883 of SWIG and you'll need to change
-a flag in the setup.py script as described below.
-
-I use the new Python Distutils tool to build wxPython.  It is included
-with Python 2.0, but if you want to use Python 1.5.2 or 1.6 then
-you'll need to download and install Distutils 1.0 from
-http://www.python.org/sigs/distutils-sig/
-
-I usually use RedHat Linux when working on the wxGTK version of
-wxPython, but I occasionally build and test on Solaris and I hope to
-be able to add some other platforms soon.  The compiler I use is
-whatever comes with the current version of RedHat I am using.  I find
-that there are less portability problems with the RPMs if I don't try
-using the latest and greatest compilers all the time.  On the other
-platforms I usually stick with as recent a version of GCC that I can
-find pre-built for that platform.
-
-Okay, now on the the fun stuff...
-
-
-1. Compile and/or install glib and gtk+
----------------------------------------
-
-A. First of all, check and see if you've already got glib/gtk+ on your
-   system, all the Linux distributions I know of come with it, at
-   least as an option.  Look for libglib.* and libgtk.* in your system's
-   standard library directories.  You'll also need the headers and
-   config scripts in order to build things that use glib/gtk.  Try
-   running gtk-config:
-
-	   gtk-config --version
-
-   If you have version 1.2.5 or better then you're all set.  You can
-   skip to step #2.
-
-B. If your system has a binary package mechanism, (RPMs, debs,
-   whatever...) check and see if binaries for glib abd gtk+ are
-   available.  Be sure to get the runtime library package as well as
-   the development package, if they are separate.  Install them with
-   your package tool, and skip to step #2.
-
-C. If all else fails, you can get the source code for glib and gtk+ at
-   http://www.gtk.org/.  Fetch the latest of each in the 1.2.x
-   series.  Compile and install each of them like this:
-
-	    gzip -d [package].tar.gz | tar xvf -
-	    cd [package]
-	    ./configure
-	    make
-	    make install
-
-   The last step will probably have to be done as root.  Also, if your
-   system needs anything done to update the dynamic loader for shared
-   libraries, (such as running ldconfig on Linux) then do it after
-   each library is installed.
-
-
-
-2. Compile and/or install wxGTK
--------------------------------
-
-A. You can find the sources and RPMs for wxGTK at
-   ftp://wesley.informatik.uni-freiburg.de/pub/linux/wxxt/source/, or
-   just follow the download links from http://wxwindows.org/.  You can
-   also check out a current snapshot of the sources from the CVS
-   server.  (Some information about annonymous CVS access is at
-   http://wxwindows.org/cvs.htm.)  The advantage of using CVS is that
-   you can easily update as soon as the developers check in new
-   sources or fixes.  The advantage of using a released version is
-   that it usually has had more testing done.  You can decide which
-   method is best for you.
-
-B. You'll usually want to use a version of wxGTK that has the same
-   version number as the wxPython sources you are using.  (Another
-   advantage of using CVS is that you'll get both at the same time.)
-
-C. If using the RPMs be sure to get both the wxGTK and wxGTK-devel
-   RPMs (at a minimum) and then install them as root.
-
-	rpm -Uhv wxGTK-2.2.2-0.i386.rpm wxGTK-devel-2.2.2-0.i386.rpm
-
-D. If using the sources (either from the tarball or from CVS) then
-   configure it like this:
-
-	cd wxWindows   # or whatever your top-level directory is called
-	mkdir build
-	cd build
-	../configure --with-gtk
-
-   There are gobs and gobs of options for the configure script, run
-   ../configure --help to see them all.  I'll describe some that I find
-   useful here.
-
-   If you have OpenGL or compatible libraries installed, then add the
-   --with-opengl flag.
-
-   If you are on Solaris and are using a recent version of GCC, then
-   you'll probably want to add the --enable-permissive flag so the
-   compiler won't barf on your broken X11 header files.
-
-   To make a debugging version of wxGTK, add the --enable-debug flag.
-   This sets the -g flag for the compiler and also activates some
-   special debugging code in wxWindows by defining the __WXDEBUG__
-   macro.  You'll get some extra asserts, failure logging, etc.
-
-   To make a static library and not make a shared library, use the
-   --disable-shared and --enable-static flags.
-
-E. Now just compile and install.  You need to use GNU make, so if your
-   system has something else get GNU make and build and install it and
-   use it instead of your system's default make command.
-
-       make
-       make install
-
-   The last step will probably have to be done as root.  Also, if your
-   system needs anything done to update the dynamic loader for shared
-   libraries, (such as running ldconfig on Linux) then do it now.
-
-F. You can test your build by changing to one of the directories under
-   build/samples or build/demos, running make and then running the
-   executable that is built.
-
-
-
-3. Compile and install wxPython
--------------------------------
-
-A. You have the same options (and same advantages/disadvantages) for
-   getting the wxPython source, either a released snapshot or from
-   CVS.  The released version file is named wxPython-[version].tar.gz
-   and is available at http://wxpython.org/download.php.  If you want
-   to use CVS you'll find wxPython in the wxWindows CVS tree (see
-   above) in the wxWindows/wxPython directory.
-
-B. As mentioned previouslly, wxPython is built with the standard
-   Python Distutils tool.  If you are using Python 2.0 or later you
-   are all set, otherwise you need to download and install Distutils
-   1.0 from http://www.python.org/sigs/distutils-sig/.
-
-   On Unix systems Distutils figures out what commands and flags to
-   use for the compiler and linker by looking in the Makefile that was
-   used to build Python itself.  Most of the time this works okay.  If
-   it doesn't, there doesn't seem to be a way to override the values
-   that Distutils uses without hacking either Distutils itself, or
-   Python's Makefile.  (Complain to the distutils-sig about this
-   please.)  For example, on my Solaris system I had to edit
-   /usr/local/lib/python1.5/config/Makefile and replace
-
-         LDSHARED=ld -G
-
-   with
-
-         LDSHARED=gcc -G
-
-   This particular problem has been fixed in Python 1.6 and beyond,
-   but there may be similar issues on other platforms.
-
-   While we're on the subject of how Python was built... Since
-   wxPython is a C++ extension some platforms and/or compilers will
-   require that the Python executable was linked with the C++ linker
-   in order for everything to work correctly.  If you build and
-   install Python yourself then this is easy to take care of,
-   otherwise you may have to mess with binary packages or bribe your
-   system administrator...
-
-   In my case on Solaris wxPython applications would core dump on
-   exit.  The core file indicated that the fault happened after
-   _exit() was called and the run-time was trying to execute cleanup
-   code.  After relinking the Python executable the problem went away.
-   To build Python to link with the C++ linker do this:
-
-         cd Python-2.0      # wherever the root of the source tree is
-	 rm python          # in case it's still there from an old build
-         make LINKCC=g++    # or whatever your C++ command is
-	 make install
-
-
-C. Change to the root wxPython directory and look at the setup.py
-   file.  This is the script that configures and defines all the
-   information that Distutils needs to build wxPython.  There are some
-   options near the begining of the script that you may want or need
-   to change based on your system and what options you have selected
-   up to this point, (sources from tar.gz or from CVS, etc.)  You can
-   either change these flags directly in setup.py or supply them on
-   the command-line.
-
-	BUILD_GLCANVAS Set to zero if you don't want to build the
-		       Open GL canvas extension module.  If you don't
-		       have OpenGL or compatible libraries then you'll
-		       need to set this to zero.
-
-	     BUILD_OGL Set to zero if you don't want to build the
-		       Object Graphics Library extension module.
-
-  	     BUILD_STC Set to zero if you don't want to build the
-		       wxStyledTextCtrl (the Scintilla wrapper)
-		       extension module.
-
-  	      USE_SWIG If you have edited any of the *.i files you
-		       will need to set this flag to non-zero so SWIG
-		       will be executed to regenerate the wrapper C++
-		       and shadow python files.
-
-	   IN_CVS_TREE If you are using the CVS version of the
-		       wxWindows and wxPython sources then you will
-		       need to set this flag to non-zero.  This is
-		       needed because some source files from the
-		       wxWindows tree are copied to be under the
-		       wxPython tree in order to keep Distutils happy.
-		       With this flag set then setup.py will
-		       automatically keep these copied sources up to
-		       date if the original version is ever updated.
-		       If you are using the tar.gz version of the
-		       Python sources then these copied sources are
-		       already present in your source tree.
-
-
-D. To build and install wxPython you simply need to execute the
-   setup.py script.  If you have more than one version of Python
-   installed, be sure to execute setup.py with the version you want to
-   build wxPython for.  Depending on the permissions on your
-   site-packages directory you may need to be root to run the install
-   command.
-
-	 python setup.py build
-   	 python setup.py install
-
-E. At this point you should be able to change into the wxPython/demo
-   directory and run the demo:
-
-	 python demo.py
-
-F. If you would like to make a test build that doesn't overwrite the
-   installed version of wxPython you can do so with this command
-   instead of the install command above:
-
-	 python setup.py build_ext --inplace
-
-   This will build the wxPython package in the local wxPython
-   directory instead of installing it under your Python installation.
-   To run using this test version just add the base wxPython source
-   directory to the PYTHONPATH:
-
-         export PYTHONPATH=~/projects/wxWindows/wxPython
-	 # or whatever is required for your shell
-	 cd ~/projects/wxWindows/wxPython/demo
-	 python demo.py
-
-
-That's all folks!
-
-
------------------
-robin@alldunn.com

wxPython/BUILD.win32.txt

@@ -1,281 +0,0 @@
-Building wxPython on Win32
---------------------------
-
-
-Building wxPython for use on win32 systems is a fairly simple process
-consisting of just a few steps.  However depending on where you get
-your sources from and what your desired end result is, there are
-several permutations of those steps.  At a high level the basic steps
-are:
-
-     1. Get the wxWindows sources
-     2. Build the wxWindows DLL
-     3. Get the wxPython sources
-     4. Build and Install wxPython
-
-We'll go into more detail of each of these steps below, but first a
-few bits of background information on tools.
-
-I use a tool called SWIG (http://www.swig.org) to help generate the
-C++ sources used in the wxPython extension module.  However you don't
-need to have SWIG unless you want to modify the *.i files.  If you do
-you'll want to have version 1.1-883 of SWIG and you'll need to change
-a flag in the setup.py script as described below.
-
-I use the new Python Distutils tool to build wxPython.  It is included
-with Python 2.0, but if you want to use Python 1.5.2 or 1.6 then
-you'll need to download and install Distutils 1.0 from
-http://www.python.org/sigs/distutils-sig/
-
-I use Microsoft Visual C++ 6.0 (5.0 with the service packs should work
-also) to compile the wxPython C++ sources.  Since I am using Distutils
-it should be easier now to build with other win32 compilers such as
-the free mingw32 or Borland compilers, but I havn't tried them yet.
-If anybody wants to try it I'll take any required patches for the
-setup script and for these instructions.
-
-And now on to the fun stuff...
-
-
-
-1. Get the wxWindows sources
-----------------------------
-
-A. There are a few possible ways to get sources for wxWindows.  You
-   can download a released version from http://wxwindows.org/ or you
-   can get current development sources from the CVS server.  (Some
-   information about annonymous CVS access is at
-   http://wxwindows.org/cvs.htm.)  The advantage of using CVS is that
-   you can easily update as soon as the developers check in new
-   sources or fixes.  The advantage of using a released version is
-   that it usually has had more testing done.  You can decide which
-   method is best for you.
-
-B. You'll usually want to use wxWindows sources that have the same
-   version number as the wxPython sources you are using.  (Another
-   advantage of using CVS is that you'll get both at the same time.)
-
-   NOTE:  There probably isn't going to be an official 2.2.2 release
-   for wxMSW so I have taken a snapshot of my workspace and made it
-   available at http://alldunn.com/wxPython/dist/others/
-
-C. Once you get the sources be sure to put them in a path without a
-   space in it (i.e., NOT c:\Program Files\wx) and set an environment
-   variable named WXWIN to this directory.  For example:
-
-	 mkdir \wx2
-	 cd \wx2
-	 unzip wxMSW-2.2.2.zip
-	 set WXWIN=c:\wx2
-
-   You'll probably want to add that last line to your autoexec.bat or
-   System Properties depending on the type of system you are on.
-
-D. Change to the wx2\include\wx\msw directory and copy setup0.h to
-   setup.h and then edit setup.h.  This is how you control which parts
-   of wxWindows are compiled into or left out of the build, simply by
-   turning options on or off.  At a minimum you should set the
-   following:
-
-	 wxUSE_NEW_GRID			    1
-	 wxUSE_GLOBAL_MEMORY_OPERATORS	    0
-	 wxUSE_LIBTIFF			    1
-	 wxUSE_GLCANVAS			    1
-	 wxDIALOG_UNIT_COMPATIBILITY	    0
-
-    I also turn off the following as they are not currently used in
-    wxPython.  There are probably others that can be turned off to
-    help save space, but I havn't investigated all the potential
-    configurations yet.  Please note that wxPython doesn't (yet) check
-    these flags for its own build, so if you turn off something that
-    wxPython expects then you'll get link errors later on.
-
-	 wxUSE_DIALUP_MANAGER		    0
-	 wxUSE_DYNLIB_CLASS		    0
-	 wxUSE_DOC_VIEW_ARCHITECTURE	    0
-	 wxUSE_MDI_ARCHITECTURE		    0
-	 wxUSE_PLOT			    0
-	 wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 0
-
-
-
-
-2. Build the wxWindows DLL
----------------------------
-
-A. Although MSVC project files are provided I always use the makefiles
-   to build wxWindows because by default the flags are compatible with
-   Python, (and I make sure they stay that way.)  You would have to
-   edit the project files a bit to make it work otherwise.
-
-B. There are three different types of wxWindows DLLs that can be
-   produced by the VC makefile simply by providing a flag on the nmake
-   command-line, I call the three types DEBUG, FINAL, and HYBRID.
-   (The last one is brand new, you'll need my version of the 2.2.2
-   sources to get the HYBRID capability.)  Here are some more details:
-
-      DEBUG Specified with "FINAL=0" and produces a DLL named
-	    wx[version]d.dll.  This DLL is compiled with full
-	    debugging information and with the __WXDEBUG__ set which
-	    enables some debugging-only code in wxWindows such as
-	    assertions and failure log messages.  The /MDd flag is
-	    used which means that it is linked with the debugging
-	    version of the C runtime library and also that you must
-	    use the debugging version of Python, (python_d.exe and
-	    pythonXX_d.dll) which also means that all extensions
-	    loaded by Python should also have the _d in the name.
-	    With this option you can use the MSVC debugger to trace
-	    though the Python interpreter, as well as the code for the
-	    wxPython extension and the wxWindows DLL.
-
-      FINAL Specified with "FINAL=1" and produces a DLL named
-            wx[version].dll.  This DLL is compiled with optimizations
-            turned on and without debugging information and without
-            __WXDEBUG__.  The /MD flag is used which means that you
-            can use this version with the standard python.exe.  This
-            is the version that I use when making the binary installer
-            for win32.
-
-     HYBRID Specified with "FINAL=hybrid" and produces a DLL named
-            wx[version]h.dll.  This DLL is almost the same as the
-            DEBUG version except the /MD flag is used which means that
-            you can use the standard python.exe but you still get the
-            debugging info and the __WXDEBUG__ code enabled.  With the
-            debugger you can trace through the the code for the
-            wxPython extension and the wxWindows DLL, but not the
-            Python interpreter.  You might use this version when you
-            want to deploy a wxPython app with the __WXDEBUG__ code
-            enabled.  I use this mode most of the time during
-            development simply because it's easier than having to
-            remember to type python_d all the time.
-
-   Since different DLL names and object file directories are used you
-   can build all three types if you like.
-
-C. Change to the wx2\src\msw directory and type the following command,
-   using the value for FINAL that you want:
-
-	 nmake -f makefile.vc dll pch USE_GLCANVAS=1 FINAL=hybrid
-
-   Your machine will then crunch away for possibly a long time,
-   depending on your hardware, and when it's done you should have a
-   DLL and some library files in \wx2\lib.
-
-D. You'll either need to add \wx2\lib to the PATH or copy the DLL file
-   to a directory already on the PATH so the DLL can be found at runtime.
-
-E. You can test your build by changing to one of the directories under
-   \wx2\samples or \wx2\demos and typing (using the right FINAL flag):
-
-	nmake -f makefile.vc FINAL=hybrid WXUSINGDLL=1
-
-   and then executing the resulting .exe file.
-
-
-
-3. Get the wxPython sources
----------------------------
-
-A. You have the same options (and same advantages/disadvantages) for
-   getting the wxPython source, either a released snapshot or from
-   CVS.  The released version file is named wxPython-[version].tar.gz
-   and is available at http://wxpython.org/download.php.  You can use
-   WinZip to unpack it if you don't have tar and gzip.  If you want to
-   use CVS you'll find wxPython in the wxWindows CVS tree (see above)
-   in the wxWindows/wxPython directory.
-
-
-
-4. Build and Install wxPython
------------------------------
-
-A. As mentioned previouslly, wxPython is built with the standard
-   Python Distutils tool.  If you are using Python 2.0c1 or later you
-   are all set, otherwise you need to download and install Distutils
-   1.0 from http://www.python.org/sigs/distutils-sig/.
-
-B. Change to the root wxPython directory and look at the setup.py
-   file.  This is the script that configures and defines all the
-   information that Distutils needs to build wxPython.  There are some
-   options near the begining of the script that you may want or need
-   to change based on what options you have selected up to this point,
-   (type of DLL built, sources from tar.gz or from CVS, etc.)  You can
-   either change these flags directly in setup.py or supply them on
-   the command-line.
-
-	BUILD_GLCANVAS Set to zero if you don't want to build the
-		       Open GL canvas extension module.
-
-	     BUILD_OGL Set to zero if you don't want to build the
-		       Object Graphics Library extension module.
-
-  	     BUILD_STC Set to zero if you don't want to build the
-		       wxStyledTextCtrl (the Scintilla wrapper)
-		       extension module.
-
-  	      USE_SWIG If you have edited any of the *.i files you
-		       will need to set this flag to non-zero so SWIG
-		       will be executed to regenerate the wrapper C++
-		       and shadow python files.
-
-	   IN_CVS_TREE If you are using the CVS version of the
-		       wxWindows and wxPython sources then you will
-		       need to set this flag to non-zero.  This is
-		       needed because some source files from the
-		       wxWindows tree are copied to be under the
-		       wxPython tree in order to keep Distutils happy.
-		       With this flag set then setup.py will
-		       automatically keep these copied sources up to
-		       date if the original version is ever updated.
-		       If you are using the tar.gz version of the
-		       Python sources then these copied sources are
-		       already present in your source tree.
-
-
-C. To build and install wxPython you simply need to execute the
-   setup.py script.  If you have more than one version of Python
-   installed, be sure to execute setup.py with the version you want to
-   build wxPython for.
-
-   Depending on what kind of wxWindows DLL you built there are
-   different command-line parameters you'll want to pass to setup (in
-   addition to possibly one or more of the above):
-
-	 FINAL:	    python setup.py install
-
-	 DEBUG:	    python setup.py build --debug install
-
-	 HYBRID:    python setup.py HYBRID=1 install
-
-
-D. At this point you should be able to change into the wxPython\demo
-   directory and run the demo:
-
-	 python demo.py
-
-E. If you would like to make a test build that doesn't overwrite the
-   installed version of wxPython you can do so with one of these
-   commands instead of the install command above:
-
-	 FINAL:	    python setup.py build_ext --inplace
-
-	 DEBUG:	    python setup.py build_ext --debug --inplace
-
-	 HYBRID:    python setup.py HYBRID=1 build_ext --inplace
-
-   This will build the wxPython package in the local wxPython
-   directory instead of installing it under your Python installation.
-   To run using this test version just add the base wxPython source
-   directory to the PYTHONPATH:
-
-         set PYTHONPATH=c:\wx2\wxPython
-	 cd c:\wx2\wxPython\demo
-	 python demo.py
-
-
-That's all folks!
-
-
------------------
-robin@alldunn.com
-

wxPython/CHANGES.txt

@@ -1,757 +0,0 @@
-CHANGES.txt for wxPython
-
-----------------------------------------------------------------------
-
-2.3b1
------
-
-New typemaps for wxString when compiling for Python 2.0 and beyond
-that allow Unicode objects to be passed as well as String objects.  If
-a Unicode object is passed PyString_AsStringAndSize is used to convert
-it to a wxString using the default encoding.
-
-Fixed the generic buttons so tool tips work for them.
-
-Fixed a bug in the demo's tree control.
-
-Added a listbox to the listbox demo that shows how to find items with
-a patching prefix as keys are typed.
-
-Added code to the wxListCtrl demo to show how to get text from a
-column in report mode.
-
-Added code to the toolbar demo to clear the long help from the status
-bar after 2 seconds.
-
-Added wxJoystick.
-
-Fixed wxTimer so it can be used as described in the docs, either with
-a Notify method in a subclass, or sending an event to a wxEvtHandler
-object, (usually a window.)
-
-Added wxNotifyEvent.Allow()
-
-Fixed GOBS of reference leaks.
-
-
-
-New in 2.2.2
-------------
-
-Significantly changed how the wxStyledtextCtrl code that wraps
-Scintilla is implemented.  Most of it is now automatically generated
-from an interface definition file provided by Scintilla.  This means
-that it will be much easier to stay in sync with new Scintilla
-releases, but also means that some of the method and identifier names
-have changed.  See wxPython/demo/data/stc.h for a copy of the C++
-interface from which the Python interface is generated.  There is now
-some inline documentation in that file that should really help explain
-how things work.
-
-I am now using the Python Distutils to build wxPython and to make some
-of the distribution files.  (See http://www.python.org/sigs/distutils-sig/)
-This means no more messing with my kludgy build.py/Makefile hack,
-builds will be more consistent with other Python extensions that also
-use Distutils, and will hopefully make wxPython easier to build for
-platforms where there have been troubles before.  If you are building
-wxPython for Python 1.5.2 or for 1.6, then you will need to get and
-install version 1.0 of Distutils from the website above.  If you are
-using Python 2.0 then you already have it.
-
-Added wxInputStream and the wxFileSystem family of classes,
-contributed by Joerg Baumann.
-
-Added wxProcess and support for it to wxExecute.  wxProcess lets you
-get notified when an asyncronous child process terminates, and also to
-get input/output streams for the child process's stdout, stderr and
-stdin.
-
-Removed the old python sizers.
-
-Added __add__, __sub__ and __cmp__ (equality check only) for wxPoint
-and wxRealPoint.
-
-Changed the build to make one big extension module instead of one for
-the core and each contrib.  This allowed me to do away with the
-libwxPyHelpers.so on unix systems.
-
-Lots of little fixes here and there.
-
-Some hacks on wxGTK to try and make the AutoComplete listbox in the
-wxStyledTextCtrl to behave better.  It's still not as nice as on
-wxMSW, but at least it's a bit more usable now.
-
-
-
-
-New in 2.2.1
-------------
-
-Various tweaks, fixes, missing methods, etc.
-
-Added example use of wxTaskBarIcon to the demo.
-
-
-
-New in 2.2.0
-------------
-
-Added wxLog and friends.
-
-Added wxFrame.ShowFullScreen for MSW.
-
-Added PyShellWindow to the wxPython.lib package.
-
-
-
-New in 2.1.16
--------------
-
-Added an attribute named labelDelta to the generic buttons that
-specifies how far to offset the label when the button is in the
-depressed state.
-
-Added wxTipProvider and friends.  See the demo for an example.
-
-wxGrid can now change the cell highlight colour.
-
-Added wxDragImage.
-
-Fixed printing on wxGTK.
-
-Added wxDateTime, wxTimeSpan, and wxDateSpan to wxPython.utils.
-
-Added wxCalendarCtrl.
-
-WARNING: A while back I asked what should be done about the Magic
-Method Names.  (Methods that are automatically turned into event
-handlers by virtue of their name.)  The consensus was that it is more
-confusing to have them than to try and expand them to have greater
-coverage.  I am finally getting around to removing the code that
-generates the event binding.  This means that if you are using any of
-the following method names without a EVT_* call that you need to
-modify your code to add the EVT_* to hook the event to the method.
-
-    OnChar
-    OnSize
-    OnEraseBackground
-    OnSysColourChanged
-    OnInitDialog
-    OnPaint
-    OnIdle
-    OnActivate
-    OnMenuHighlight
-    OnCloseWindow
-    OnScroll
-
-Added wxSpinCtrl.
-
-
-
-
-New in 2.1.15
--------------
-
-Fixed wxTreeCtrl.HitTest to return both the tree item as well as the
-flags that clairify where the click was in relation to the item.
-
-Fixed thread state problem in wxTreeCtrl.GetBoundingBox and
-GetSelections.
-
-Fixed some problems in OGL.  Also wxShape.SetClientData and
-.GetClientData can now deal with Python objects.
-
-Added wxListCtrl.SortItems and changed the demo to show how to use it.
-
-Plugged a memory leak.
-
-Wrapped the new wxGrid and friends.  The old wxGrid class is no longer
-available.  There are some incompatibilities, and unfortunately the
-new classes are not documented yet, (however the methods are more
-consistent with each other now so you may be able to guess pretty
-good...)
-
-Updated filebrowsebutton.py and calendar.py with changes from their
-authors.  There is now a FileBrowseButtonWithHistory class (what a
-mouthful!) and wxCalendar has printing support.
-
-Added ActiveXWrapper to the library, and some good demos of it too.
-It works great for embedding a COM (a.k.a OCX, a.k.a ActiveX) control
-in a window and calling its methods.  It actually creates a new class
-on the fly that derives from wxWindow, the COM CoClass and others
-needed to make it all work.  The resulting class can be instantiated
-just like wxWindow, used in sizers, etc.  It also responds to all COM
-method calls, properties, etc., and if the class or a mix-in has
-matching method names, then the COM events will be propogated back to
-them.
-
-Created a typemap that allows a string to be used for parameters
-expecting a wxColour type.  The string is either a colour name as
-defined in the wxColourDatabase, or a colour spec of the form
-"#RRGGBB".  See the wxStyledTextCtrl demo for an example.
-
-I almost forgot to mention the wxStyledTextCtrl!  Yes, the
-wxStyledTextCtrl is finally in wxPython!!  (And the crowd goes
-wild...)   There's no documentaTion yet (the crowd boos and hisses...)
-but I've included a very readable source file in the
-wxPython/demo/data directory, a couple fairly good examples, and you
-can also refer to the Scintilla documentaion at
-http://www.scintilla.org/ScintillaDoc.html to help fill in the gaps
-until the docs are done.  (The croud murmers contentedly as the tool
-provider smiles convincingly and removes his flame-proof suit.)
-
-
-
-
-What's new in 2.1.13
---------------------
-Skipped a version number to match what has been released for wxGTK.
-
-Updated wxMVCTree and added a demo for it, also fixed layout on GTK
-and some flicker problems.
-
-Added a wrapper class for the Visualization ToolKit (or VTK) in the
-wxPython.lib.vtk module.  (http://www.kitware.com/)
-
-Fixed wxTreeCtrl.SetItemImage and GetItemImage to recognise the new
-"which" parameter.
-
-Added wxPython.lib.spashscreen from Mike Fletcher.
-
-Added wxPython.lib.filebrowsebutton also from Mike Fletcher.
-
-Renamed wxTreeCtrl.GetParent to GetItemParent to avoid a name clash
-with wxWindow.GetParent.
-
-Added wxIntersectRect to compute the intersection of two wxRect's.
-It is used like this:
-
-   intersect = wxIntersectRect(rect1, rect2)
-
-If r1 and r2 don't intersect then None is returned, otherwise the
-rectangle representing the intersection is returned.
-
-Some bug fixes for Clipboard and Drag-n-Drop.
-
-Rotated text!!!  WooHoo!  (See wxDC.DrawRotatedText())
-
-Added a set of Generic Buttons to the library.  These are simple
-window classes that look and act like native buttons, but you can have
-a bit more control over them.  The bezel width can be set in addition
-to colours, fonts, etc.  There is a ToggleButton as well as Bitmap
-versions too.  They should also serve as a good example of how to
-create your own classes derived from wxControl.
-
-The C++ wxToolBar classes have been redone, and so have the wxPython
-wrappers.  There have been slight modifications to some of the methods
-but shouldn't impact anybody too much.  I took the opportunity to add
-support for setting user data on each toolbar tool.  The new AddTool
-methods look like this:
-
-        def AddTool(ID,
-                    bitmap,
-                    pushedBitmap = wxNullBitmap,
-                    toggle = FALSE,
-                    clientData = NULL,
-                    shortHelpString = "",
-                    longHelpString = "")
-
-        def AddSimpleTool(ID,
-                          bitmap,
-                          shortHelpString = "",
-                          longHelpString = "",
-                          toggle=FALSE)
-
-
-There are also coresponding InsertTool and InsertSimpleTool methods
-that additionally take an integer position as the first parameter.
-
-Added a wrapper for the new PCX and TIFF ImageHandlers.
-
-wxRect now simulates attributes named left, right, top and bottom.
-
-Removed all non wx stuff from the glcanvas module since DA's PyOpenGL
-is better and compatible with the wxGLCanvas.  You can get it at
-http://starship.python.net:9673/crew/da/Code/PyOpenGL.
-
-Added some missing EVT_ functions.
-
-Added Dirk Holtwic's editor classes to the wxPython.lib.editor
-package.
-
-Changed all the "LIST" parameter names to "choices" to match the docs.
-
-More fixes for the wxFloatBar, and it now works on wxGTK even better
-than wxMSW!  (The feat is accomplished by using the wxTB_DOCKABLE
-style flag instead of trying to float it ourselves.)
-
-
-
-
-What's new in 2.1.11
---------------------
-Skipped a few version numbers so wxMSW, wxGTK and wxPython are all
-syncronized.
-
-wxImage.SetData now makes a copy of the image data before giving it to
-wxImage.  I mistakenly thought that wxImage would copy the data
-itself.
-
-Fixed wxMSW's notebook so the pages get their size set as they are
-being added.  This should remove the need for our
-wxNotebook.ResizeChildren hack.
-
-wxPanels now support AutoLayout, and wxNotebooks and wxSplitterWindows
-no longer tell their children to Layout() themselves.  This will
-probably only effect you if you have a wxWindow with AutoLayout inside
-a notebook or splitter.  If so, either change it to a wxPanel or add
-an EVT_SIZE handler that calls Layout().
-
-Fixed deadlock problem that happened when using threads.
-
-Added new HTML printing classes.
-
-Added wxWindow.GetHandle
-
-Apparently wxMouseEvent.Position has been depreciated in wxWindows as
-it is no longer available by default.  You can use GetPositionTuple
-(returning a tuple with x,y) instead, or GetPosition (returning a
-wxPoint.)
-
-Added wxPostEvent function that allows events to be posted and then
-processed later.  This is a thread-safe way to interact with the GUI
-thread from other threads.
-
-Added Clipboard and Drag-and-Drop classes.
-
-Added wxFontEnumerator.
-
-Many updates to wxMenu, wxMenuBar.
-
-wxPyEvent and wxPyCommandEvent derived classes now give you the actual
-Python object in the event handler instead of a new shadow.
-
-Added a Calendar widget from Lorne White to the library.
-
-Made some fixes to the wxFloatbar.  It still has some troubles on
-wxGTK...
-
-Added an MVC tree control from Bryn Keller to the library.
-
-
-
-
-What's new in 2.1.5
--------------------
-This is a quick bug-fix release to take care of a few nasties that
-crept in at the last minute before 2.1.4 was called done.  No new
-major features.
-
-
-
-What's new in 2.1.4
---------------------
-
-This release is NOT syncronized with a snapshot release of wxGTK or
-wxMSW.  For MSW this isn't much of a problem since you can get the
-binaries from the web site.  For other platforms you'll have to build
-wxGTK from CVS.  (See http://web.ukonline.co.uk/julian.smart/wxwin/cvs.htm)
-To get the same set of sources from CVS that I used, checkout using
-the wxPy-2-1-4 tag.
-
-Now back to what's new...
-
-Much more support for event-less callbacks and add-on modules.
-
-Created add-on module with wxOGL classes.
-
-Added wxWindow.GetChildren().  Be careful of this.  It returns a *copy*
-of the list of the window's children.  While you are using the list if
-anything changes in the real list (a child is deleted, etc.) then the
-list you are holding will suddenly have window references to garbage
-memory and your app will likely crash.  But if you are careful it works
-great!
-
-Added a bunch of new and missing methods to wxTreeCrtl.  The
-SortChildren method is now supported, but currently only for the
-default sort order.
-
-Added typemaps for wxSize, wxPoint, wxRealPoint, and wxRect that allow
-either the actual objects or Python sequence values to be used.  For
-example, the following are equivallent:
-
-    win = wxWindow(parent, size = wxSize(100, 100))
-    win = wxWindow(parent, size = (100, 100))
-
-Super-charged the wxHtml module.  You can now create your own tag
-handlers and also have access to the parser and cell classes.  There
-is a tag handler in the library at wxPython.lib.wxpTag that
-understands the WXP tag and is able to place wxPython windows on HTML
-pages.  See the demo for an example.
-
-A bunch of the methods of wxMenuBar were previously ifdef'd out for
-wxGTK.  Added them back in since the methods exist now.
-
-Wrapped the wxHtmlHelpController and related classes.
-
-Wrapped the C++ versions of wxSizer and friends.  The Python-only
-versions are still in the library, but depreciated.  (You will get a
-warning message if you try to use them, but the warning can be
-disabled.) The usage of the C++ versions is slightly different, and
-the functionality of wxBorderSizer is now part of wxBoxSizer.  I have
-added a few methods to wxSizer to try and make the transition as
-smooth as possible, I combined all Add methods into a single method
-that handles all cases, added an AddMany method, etc.  One step I did
-not take was to make the default value of flag in the Add method be
-wxGROW.  This would have made it more backward compatible, but less
-portable to and from wxWin C++ code.  Please see the docs and demo for
-further details.
-
-Added wxPyEvent and wxPyCommandEvent classes, derived from wxEvent and
-wxCommandEvent.  Each of them has SetPyData and GetPyData methods that
-accept or return a single Python object.  You can use these classes
-directly or derive from them to create your own types of event objects
-that can pass through the wxWindows event system without loosing their
-Python parts (as long as they are stored with SetPyData.)  Stay tuned
-for more info and examples in future releases.
-
-Added wxPython.lib.grids as an example of how to derive a new sizer
-from the C++ sizers.  In this module you will find wxGridSizer and
-wxFlexGridSizer.  wxGridSizer arrainges its items in a grid in which
-all the widths and heights are the same.  wxFlexgridSizer allows
-different widths and heights, and you can also specify rows and/or
-columns that are growable.  See the demo for a couple examples for how
-to use them.
-
-Added the wxValidator class, and created a class named wxPyValidator
-that should be used for the base class of any Python validators.  See
-the demo for an example.  Please note that you MUST implement a Clone
-method in your validator classes because of the way some things work
-in the underlying C++ library.  I did not add wxTextValidator because
-of some issues of how it transfers data to and from a wxString, which
-in wxPython is automatically translated to and from Python strings, so
-there would never be a concrete wxString that would hang around long
-enough for the validator to do its job.  On the other hand, it should
-be real easy to duplicate the functionality of wxTextValidator in a
-pure Python class derived from wxPyValidator.
-
-I've finally added a feature that has been on my list for close to two
-years!  Ever wondered what that zero is for when you create your app
-object?  Well now you can leave it out or explicitly set it to a true
-value.  This value now controls what is to be done with sys.stdout and
-sys.stderr.  A false value leaves them alone, and a true value sets
-them to an instance of wxPyOnDemandOutputWindow.  (On windows the
-default is true, on unix platforms the default is false.)  This class
-creates a frame containing a wxTextCtrl as soon as anything is written
-to sys.stdout or sys.stderr.  If you close the window it will come
-back again the next time something is written.  (You can call
-app.RestoreStdio to turn this off.)  If you would rather that the stdio be
-redirected to a file, you can provide a second parameter to your app
-object's constructor that is a filename.  If you want to use your own
-class instead of wxPyOnDemandOutputWindow you can either implement
-RedirectStdio() in you app class or change the value of
-wxApp.outputWindowClass like this:
-
-    class MyApp(wxApp):
-        outputWindowClass = MyClass
-
-        def OnInit(self):
-            frame = MyFrame()
-            self.SetTopWindow(frame)
-            return true
-
-Please see the implementation of wxPyOnDemandOutputWindow and wxApp in
-wx.py for more details.  A few words of caution:  if you are running
-your app in a debugger, changing sys.stdout and sys.stderr is likely
-to really screw things up.
-
-Added wxCaret.  Unfortunately it's author has still not documented it
-in the wxWindows docs...
-
-Some new 3rd party contributions in wxPython.lib.  PyShell, in
-shell.py is an interesting implementaion of an interactive Python
-shell in wxWindows.  floatbar.py has a class derived from wxToolBar
-that can sense mouse drags and then reparent itself into another
-frame. Moving the new frame close to where it came from puts the tool
-bar back into the original parent.  (Unfortunately there is currently
-a bug in wxGTK's wxFrame.SetToolBar so the FloatBar has some
-problems...)
-
-
-
-
-What's new in 2.1b3
---------------------
-
-This release is syncronized with release 2.1 snapshot 9 of wxWindows.
-
-Switched to using SWIG from CVS (see http://swig.cs.uchicago.edu/cvs.html)
-for some of the new features and such.  Also they have encorporated my
-patches so there is really no reason to stick with the current (very
-old) release...  This version of SWIG gives the following new
-features:
-
-    1. Keyword arguments.  You no longer have to specify all the
-       parameters with defaults to a method just to specify a
-       non-default value on the end.  You can now do this instead:
-
-          win = wxWindow(parent, -1, style = mystyle)
-
-    2. There is now an an equivalence between Python's None and C++'s
-       NULL.  This means that any methods that might return NULL will
-       now return None and you can use none where wxWindows might be
-       expecting NULL.  This makes things much more snake-ish.
-
-
-There is a new build system based on a new Python program instead of
-raw makefiles.  Now wxPython builds are virtually the same on MSW or
-Unix systems.  See the end of this file for new build instructions and
-see distrib/build.py for more details.
-
-wxDC.Bilt now includes the useMask parameter, and has been split into
-two different versions.  wxDC.BlitXY is like what was there before and
-takes raw coordinants and sizes, and the new wxDC.Blit is for the new
-interface using wxPoints and a wxSize.
-
-
-
-
-
-What's new in 2.1b2
---------------------
-
-Added the missing wxWindow.GetUpdateRegion() method.
-
-Made a new change in SWIG (update your patches everybody) that
-provides a fix for global shadow objects that get an exception in
-their __del__ when their extension module has already been deleted.
-It was only a 1 line change in .../SWIG/Modules/pycpp.cxx at about
-line 496 if you want to do it by hand.
-
-It is now possible to run through MainLoop more than once in any one
-process.  The cleanup that used to happen as MainLoop completed (and
-prevented it from running again) has been delayed until the wxc module
-is being unloaded by Python.
-
-I fixed a bunch of stuff in the C++ version of wxGrid so it wouldn't
-make wxPython look bad.
-
-wxWindow.PopupMenu() now takes a wxPoint instead of  x,y.  Added
-wxWindow.PopupMenuXY to be consistent with some other methods.
-
-Added wxGrid.SetEditInPlace and wxGrid.GetEditInPlace.
-
-You can now provide your own app.MainLoop method.  See
-wxPython/demo/demoMainLoop.py for an example and some explaination.
-
-Got the in-place-edit for the wxTreeCtrl fixed and added some demo
-code to show how to use it.
-
-Put the wxIcon constructor back in for GTK as it now has one that
-matches MSW's.
-
-Added wxGrid.GetCells
-
-Added wxSystemSettings static methods as functions with names like
-wxSystemSettings_GetSystemColour.
-
-Removed wxPyMenu since using menu callbacks have been depreciated in
-wxWindows.  Use wxMenu and events instead.
-
-Added alternate wxBitmap constructor (for MSW only) as
-      wxBitmapFromData(data, type, width, height, depth = 1)
-
-Added a helper function named wxPyTypeCast that can convert shadow
-objects of one type into shadow objects of another type.  (Like doing
-a down-cast.)  See the implementation in wx.py for some docs.
-
-Fixed wxImage GetData and SetData to properly use String objects for
-data transfer.
-
-Added access methods to wxGridEvent.
-
-New Makefile/Setup files supporting multiple dynamic extension modules
-for unix systems.
-
-Fixes for the wxGLCanvas demo to work around a strange bug in gtk.
-
-SWIG support routines now compiled separately instead of being bundled
-in wx.cpp.
-
-
-
-
-
-What's new in 2.1b1
---------------------
-Fixed wxComboBox.SetSelection so that it actually sets the selected
-item.  (Actually just removed it from wxPython and let it default to
-wxChoice.SetSelection which was already doing the right thing.)
-
-Added the Printing Framework.
-
-Switched back to using the wxWindows DLL for the pre-built Win32
-version.  The problem was needing to reinitialize static class info
-data after loading each extension module.
-
-Lots of little tweaks and additions to reflect changes to various
-wxWindows classes.
-
-Fixed a bug with attaching objects to tree items.  Actually was a
-symptom of a larger problem with not obtaining the interpreter lock
-when doing any Py_DECREFs.
-
-wxSizer and friends.  Sizers are layout tools that manage a colection
-of windows and sizers.  Different types of sizers apply different
-types of layout algorithms.  You saw it here first!  These classes are
-not even in the wxWindows C++ library yet!
-
-
-
-What's new in 2.0b9
--------------------
-Bug fix for ListCtrl in test4.py (Was a missing file...  DSM!)
-
-Bug fix for occassional GPF on Win32 systems upon termination of a
-wxPython application.
-
-Added wxListBox.GetSelections returning selections as a Tuple.
-
-Added a wxTreeItemData that is able to hold any Python object and be
-associated with items in a wxTreeCtrl.  Added test pytree.py to show
-this feature off.
-
-Added wxSafeYield function.
-
-OpenGL Canvas can be optionally compiled in to wxPython.
-
-Awesome new Demo Framework for showing off wxPython and for learning
-how it all works.
-
-The pre-built Win32 version is no longer distributing the wxWindows
-DLL.  It is statically linked with the wxWindows library instead.
-
-Added a couple missing items from the docs.
-
-Added wxImage, wxImageHandler, wxPNGHandler, wxJPEGHandler,
-wxGIFHandler and wxBMPHandler.
-
-Added new methods to wxTextCtrl.
-
-Fixed some problems with how SWIG was wrapping some wxTreeCtrl
-methods.
-
-
-
-What's new in 2.0b8
--------------------
-Support for using Python threads in wxPython apps.
-
-Several missing methods from various classes.
-
-Various bug fixes.
-
-
-
-What's new in 2.0b7
--------------------
-Added DLG_PNT and DLG_SZE convienience methods to wxWindow class.
-
-Added missing constructor and other methods for wxMenuItem.
-
-
-
-What's new in 2.0b6
--------------------
-Just a quickie update to fix the self-installer to be compatible with
-Python 1.5.2b2's Registry settings.
-
-
-What's new in 2.0b5
--------------------
-Well obviously the numbering scheme has changed.  I did this to
-reflect the fact that this truly is the second major revision of
-wxPython, (well the third actually if you count the one I did for
-wxWindows 1.68 and then threw away...) and also that it is associated
-with the 2.0 version of wxWindows.
-
-I have finally started documenting wxPython.  There are several pages
-in the wxWindows documentation tree specifically about wxPython, and I
-have added notes within the class references about where and how wxPython
-diverges from wxWindows.
-
-Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
-window handle.  If you can get the window handle into the python code,
-it should just work...  More news on this later.
-
-Added wxImageList, wxToolTip.
-
-Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
-wxRegConfig class.
-
-As usual, some bug fixes, tweaks, etc.
-
-
-
-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.
-
-----------------------------------------------------------------------

wxPython/MANIFEST.in

@@ -1,92 +0,0 @@
-include *.txt
-include my_distutils.py
-## include my_install_data.py
-include licence/*.txt
-
-include demo/*.py
-include demo/bitmaps/*.bmp
-include demo/bitmaps/*.ico
-include demo/bitmaps/*.gif
-include demo/bitmaps/*.png
-include demo/bitmaps/*.jpg
-include demo/README.txt
-include demo/*.xml
-include demo/data/*.png
-include demo/data/*.htm
-include demo/data/*.html
-include demo/data/*.bmp
-include demo/data/*.txt
-include demo/data/*.i
-include demo/data/*.h
-include demo/data/*.py
-
-include wxPython/lib/*.py
-include wxPython/lib/*.txt
-include wxPython/lib/editor/*.py
-include wxPython/lib/editor/*.txt
-
-exclude wxPython/*
-exclude tests
-exclude SWIG
-
-include src/*.i
-include src/*.py
-include src/*.cpp
-include src/*.c
-include src/*.h
-include src/*.ico
-include src/*.rc
-
-include src/msw/*.cpp
-include src/msw/*.h
-include src/msw/*.py
-
-include src/gtk/*.cpp
-include src/gtk/*.h
-include src/gtk/*.py
-
-# src/motif/*.cpp
-# src/motif/*.h
-# src/motif/*.py
-
-
-include contrib/glcanvas/*.i
-include contrib/glcanvas/*.py
-include contrib/glcanvas/*.cpp
-include contrib/glcanvas/*.c
-include contrib/glcanvas/*.h
-include contrib/glcanvas/msw/*.cpp
-include contrib/glcanvas/msw/*.h
-include contrib/glcanvas/msw/*.py
-include contrib/glcanvas/gtk/*.cpp
-include contrib/glcanvas/gtk/*.h
-include contrib/glcanvas/gtk/*.py
-
-include contrib/ogl/*.txt
-include contrib/ogl/*.i
-include contrib/ogl/*.py
-include contrib/ogl/*.cpp
-include contrib/ogl/*.c
-include contrib/ogl/*.h
-include contrib/ogl/contrib/include/wx/ogl/*.h
-include contrib/ogl/contrib/src/ogl/*.cpp
-
-include contrib/stc/*.txt
-include contrib/stc/*.i
-include contrib/stc/*.py
-include contrib/stc/*.cpp
-include contrib/stc/*.c
-include contrib/stc/*.h
-include contrib/stc/*.cpp
-include contrib/stc/*.py
-include contrib/stc/contrib/include/wx/stc/*.h
-include contrib/stc/contrib/src/stc/*.h
-include contrib/stc/contrib/src/stc/*.cpp
-include contrib/stc/contrib/src/stc/*.txt
-include contrib/stc/contrib/src/stc/*.py
-include contrib/stc/contrib/src/stc/*.in
-include contrib/stc/contrib/src/stc/scintilla/include/*.h
-include contrib/stc/contrib/src/stc/scintilla/include/*.iface
-include contrib/stc/contrib/src/stc/scintilla/src/*.h
-include contrib/stc/contrib/src/stc/scintilla/src/*.cxx
-

wxPython/README.txt

@@ -1,85 +0,0 @@
-wxPython README
----------------
-
-Welcome to the wonderful world of wxPython!
-
-Once you have installed the wxPython extension module, you can try it
-out by going to the [install dir]\wxPython\demo directory and typing:
-
-    python demo.py
-
-There are also some other sample files there for you to play with and
-learn from.
-
-If you selected to install the documentation then point your browser
-to [install dir]\wxPython\docs\index.htm and you will then be looking
-at the docs for wxWindows.  For the most part you can use the C++ docs
-as most classes and methods are used identically.  Where there are
-differences they are documented with a "wxPython Note."
-
-On Win32 systems the binary self-installer creates a program group on
-the Start Menu that contains a link to running the demo and a link to
-the help file.  To help you save disk space I'm now using Microsoft's
-HTML Help format.  If your system doesn't know what to do with the help
-file, you can install the HTML Help Viewer as part of IE 4+, NT
-Service Pack 4+, or the HTML Workshop at
-
-http://msdn.microsoft.com/workshop/author/htmlhelp/download.asp.
-
-For some features, the latest common controls library from microsoft
-is required.  You can get this by installing IE 5.0 or Office 2000.
-You can also get it independently from here:
-
-http://download.microsoft.com/download/platformsdk/Comctl32/5.80.2614.3600/W9XNT4/EN-US/50comupd.exe
-
-Windows 95 users may also need the WinSock 2.0 and OpenGL libraries.
-These can be found at these sites:
-
-
-http://www.microsoft.com/windows95/downloads/contents/wuadmintools/s_wunetworkingtools/w95sockets2/default.asp
-
-http://www.opengl.org/Downloads/Downloads.html
-
-
-
-Getting Help
-------------
-
-Since wxPython is a blending of multiple technologies, help comes from
-multiple sources.  See the http://wxPython.org/ for details on various
-sources of help, but probably the best source is the wxPython-users
-mail list.  You can view the archive or subscribe by going to
-
-       http://lists.sourceforge.net/mailman/listinfo/wxpython-users
-
-Or you can send mail directly to the list using this address:
-
-       wxpython-users@lists.sourceforge.net
-
-
-Other Info
-----------
-
-Please also see the following files in this directory:
-
-       CHANGES.txt     Information about new features, fixes, etc. in
-                       each release.
-
-       BUILD.unix.txt  Instructions for building wxPython on various
-		       Unix-like platforms.
-
-       BUILD.win32.txt Instructions for building wxPython on Windows.
-
-       licence/*       Text of the wxWindows license.
-
-
------------------
-Robin Dunn
-robin@alldunn.com
-
-
-
-
-
-
-

wxPython/SWIG/README.txt

@@ -1,6 +0,0 @@
-
-Some minor tweaks were made to these files to allow wxPython to build
-with Python 1.6.  Just put these in your swig_lib/python dir and
-you'll be all set.  These are from SWIG 1.1-810, (yes, I am a bit
-behind.)
-

wxPython/SWIG/pyexp.swg

@@ -1,32 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif

wxPython/SWIG/typemaps.i

@@ -1,561 +0,0 @@
-//
-// SWIG Typemap library
-// Dave Beazley
-// May 5, 1997
-//
-// Python implementation
-//
-// This library provides standard typemaps for modifying SWIG's behavior.
-// With enough entries in this file, I hope that very few people actually
-// ever need to write a typemap.
-//
-// Disclaimer : Unless you really understand how typemaps work, this file
-// probably isn't going to make much sense.
-//
-#ifdef AUTODOC
-%section "Typemap Library (Python)",info,after,pre,nosort,skip=1,chop_left=3,chop_right=0,chop_top=0,chop_bottom=0
-%text %{
-%include typemaps.i
-
-The SWIG typemap library provides a language independent mechanism for
-supporting output arguments, input values, and other C function
-calling mechanisms.  The primary use of the library is to provide a
-better interface to certain C function--especially those involving
-pointers.
-%}
-
-#endif
-
-// ------------------------------------------------------------------------
-// Pointer handling
-//
-// These mappings provide support for input/output arguments and common
-// uses for C/C++ pointers.
-// ------------------------------------------------------------------------
-
-// INPUT typemaps.
-// These remap a C pointer to be an "INPUT" value which is passed by value
-// instead of reference.
-
-
-#ifdef AUTODOC
-%subsection "Input Methods"
-
-%text %{
-The following methods can be applied to turn a pointer into a simple
-"input" value.  That is, instead of passing a pointer to an object,
-you would use a real value instead.
-
-         int            *INPUT
-         short          *INPUT
-         long           *INPUT
-         unsigned int   *INPUT
-         unsigned short *INPUT
-         unsigned long  *INPUT
-         unsigned char  *INPUT
-         float          *INPUT
-         double         *INPUT
-
-To use these, suppose you had a C function like this :
-
-        double fadd(double *a, double *b) {
-               return *a+*b;
-        }
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        double fadd(double *INPUT, double *INPUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *INPUT { double *a, double *b };
-        double fadd(double *a, double *b);
-
-%}
-#endif
-
-%typemap(python,in) double *INPUT(double temp)
-{
-  temp = PyFloat_AsDouble($source);
-  $target = &temp;
-}
-
-%typemap(python,in) float  *INPUT(float temp)
-{
-  temp = (float) PyFloat_AsDouble($source);
-  $target = &temp;
-}
-
-%typemap(python,in) int            *INPUT(int temp)
-{
-  temp = (int) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) short          *INPUT(short temp)
-{
-  temp = (short) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) long           *INPUT(long temp)
-{
-  temp = (long) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned int   *INPUT(unsigned int temp)
-{
-  temp = (unsigned int) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned short *INPUT(unsigned short temp)
-{
-  temp = (unsigned short) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned long  *INPUT(unsigned long temp)
-{
-  temp = (unsigned long) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned char  *INPUT(unsigned char temp)
-{
-  temp = (unsigned char) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) signed char  *INPUT(signed char temp)
-{
-  temp = (unsigned char) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-// OUTPUT typemaps.   These typemaps are used for parameters that
-// are output only.   The output value is appended to the result as
-// a list element.
-
-#ifdef AUTODOC
-%subsection "Output Methods"
-
-%text %{
-The following methods can be applied to turn a pointer into an "output"
-value.  When calling a function, no input value would be given for
-a parameter, but an output value would be returned.  In the case of
-multiple output values, they are returned in the form of a Python tuple.
-
-         int            *OUTPUT
-         short          *OUTPUT
-         long           *OUTPUT
-         unsigned int   *OUTPUT
-         unsigned short *OUTPUT
-         unsigned long  *OUTPUT
-         unsigned char  *OUTPUT
-         float          *OUTPUT
-         double         *OUTPUT
-
-A Python List can also be returned by using L_OUTPUT instead of OUTPUT.
-
-For example, suppose you were trying to wrap the modf() function in the
-C math library which splits x into integral and fractional parts (and
-returns the integer part in one of its parameters).K:
-
-        double modf(double x, double *ip);
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        double modf(double x, double *OUTPUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *OUTPUT { double *ip };
-        double modf(double x, double *ip);
-
-The Python output of the function would be a tuple containing both
-output values.
-%}
-#endif
-
-// Helper function for List output
-
-%{
-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;
-}
-%}
-
-// Force the argument to be ignored.
-
-%typemap(python,ignore) int            *L_OUTPUT(int temp),
-                        short          *L_OUTPUT(short temp),
-                        long           *L_OUTPUT(long temp),
-                        unsigned int   *L_OUTPUT(unsigned int temp),
-                        unsigned short *L_OUTPUT(unsigned short temp),
-                        unsigned long  *L_OUTPUT(unsigned long temp),
-                        unsigned char  *L_OUTPUT(unsigned char temp),
-                        signed char    *L_OUTPUT(signed char temp),
-                        float          *L_OUTPUT(float temp),
-                        double         *L_OUTPUT(double temp)
-{
-  $target = &temp;
-}
-
-%typemap(python,argout) int            *L_OUTPUT,
-                        short          *L_OUTPUT,
-                        long           *L_OUTPUT,
-                        unsigned int   *L_OUTPUT,
-                        unsigned short *L_OUTPUT,
-                        unsigned long  *L_OUTPUT,
-                        unsigned char  *L_OUTPUT,
-                        signed char    *L_OUTPUT
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*$source));
-    l_output_helper($target,o);
-}
-
-%typemap(python,argout) float    *L_OUTPUT,
-                        double   *L_OUTPUT
-{
-    PyObject *o;
-    o = PyFloat_FromDouble((double) (*$source));
-    $target = l_output_helper($target,o);
-}
-
-// These typemaps contributed by Robin Dunn
-//----------------------------------------------------------------------
-//
-// T_OUTPUT typemap (and helper function) to return multiple argouts as
-// a tuple instead of a list.
-//
-// Author: Robin Dunn
-//----------------------------------------------------------------------
-
-%{
-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;
-}
-%}
-
-// Force the argument to be ignored.
-%typemap(python,ignore) int            *T_OUTPUT(int temp),
-                        short          *T_OUTPUT(short temp),
-                        long           *T_OUTPUT(long temp),
-                        unsigned int   *T_OUTPUT(unsigned int temp),
-                        unsigned short *T_OUTPUT(unsigned short temp),
-                        unsigned long  *T_OUTPUT(unsigned long temp),
-                        unsigned char  *T_OUTPUT(unsigned char temp),
-                        float          *T_OUTPUT(float temp),
-                        double         *T_OUTPUT(double temp)
-{
-  $target = &temp;
-}
-
-%typemap(python,argout) int            *T_OUTPUT,
-                        short          *T_OUTPUT,
-                        long           *T_OUTPUT,
-                        unsigned int   *T_OUTPUT,
-                        unsigned short *T_OUTPUT,
-                        unsigned long  *T_OUTPUT,
-                        unsigned char  *T_OUTPUT
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*$source));
-    $target = t_output_helper($target, o);
-}
-
-%typemap(python,argout) float    *T_OUTPUT,
-                        double   *T_OUTPUT
-{
-    PyObject *o;
-    o = PyFloat_FromDouble((double) (*$source));
-    $target = t_output_helper($target, o);
-}
-
-// Set the default output typemap
-
-#ifdef OUTPUT_LIST
-%typemap(python,ignore) int                *OUTPUT = int   *L_OUTPUT;
-%typemap(python,ignore) short              *OUTPUT = short *L_OUTPUT;
-%typemap(python,ignore) long               *OUTPUT = long  *L_OUTPUT;
-%typemap(python,ignore) unsigned           *OUTPUT = unsigned *L_OUTPUT;
-%typemap(python,ignore) unsigned short     *OUTPUT = unsigned short *L_OUTPUT;
-%typemap(python,ignore) unsigned long      *OUTPUT = unsigned long  *L_OUTPUT;
-%typemap(python,ignore) unsigned char      *OUTPUT = unsigned char  *L_OUTPUT;
-%typemap(python,ignore) signed char        *OUTPUT = signed char    *L_OUTPUT;
-%typemap(python,ignore) double             *OUTPUT = double         *L_OUTPUT;
-%typemap(python,ignore) float              *OUTPUT = float          *L_OUTPUT;
-
-%typemap(python,argout) int                *OUTPUT = int   *L_OUTPUT;
-%typemap(python,argout) short              *OUTPUT = short *L_OUTPUT;
-%typemap(python,argout) long               *OUTPUT = long  *L_OUTPUT;
-%typemap(python,argout) unsigned           *OUTPUT = unsigned *L_OUTPUT;
-%typemap(python,argout) unsigned short     *OUTPUT = unsigned short *L_OUTPUT;
-%typemap(python,argout) unsigned long      *OUTPUT = unsigned long  *L_OUTPUT;
-%typemap(python,argout) unsigned char      *OUTPUT = unsigned char  *L_OUTPUT;
-%typemap(python,argout) signed char        *OUTPUT = signed char    *L_OUTPUT;
-%typemap(python,argout) double             *OUTPUT = double         *L_OUTPUT;
-%typemap(python,argout) float              *OUTPUT = float          *L_OUTPUT;
-#else
-%typemap(python,ignore) int                *OUTPUT = int   *T_OUTPUT;
-%typemap(python,ignore) short              *OUTPUT = short *T_OUTPUT;
-%typemap(python,ignore) long               *OUTPUT = long  *T_OUTPUT;
-%typemap(python,ignore) unsigned           *OUTPUT = unsigned *T_OUTPUT;
-%typemap(python,ignore) unsigned short     *OUTPUT = unsigned short *T_OUTPUT;
-%typemap(python,ignore) unsigned long      *OUTPUT = unsigned long  *T_OUTPUT;
-%typemap(python,ignore) unsigned char      *OUTPUT = unsigned char  *T_OUTPUT;
-%typemap(python,ignore) signed char        *OUTPUT = signed char    *T_OUTPUT;
-%typemap(python,ignore) double             *OUTPUT = double         *T_OUTPUT;
-%typemap(python,ignore) float              *OUTPUT = float          *T_OUTPUT;
-
-%typemap(python,argout) int                *OUTPUT = int   *T_OUTPUT;
-%typemap(python,argout) short              *OUTPUT = short *T_OUTPUT;
-%typemap(python,argout) long               *OUTPUT = long  *T_OUTPUT;
-%typemap(python,argout) unsigned           *OUTPUT = unsigned *T_OUTPUT;
-%typemap(python,argout) unsigned short     *OUTPUT = unsigned short *T_OUTPUT;
-%typemap(python,argout) unsigned long      *OUTPUT = unsigned long  *T_OUTPUT;
-%typemap(python,argout) unsigned char      *OUTPUT = unsigned char  *T_OUTPUT;
-%typemap(python,argout) signed char        *OUTPUT = signed char    *T_OUTPUT;
-%typemap(python,argout) double             *OUTPUT = double         *T_OUTPUT;
-%typemap(python,argout) float              *OUTPUT = float          *T_OUTPUT;
-#endif
-
-// INOUT
-// Mappings for an argument that is both an input and output
-// parameter
-
-
-#ifdef AUTODOC
-%subsection "Input/Output Methods"
-
-%text %{
-The following methods can be applied to make a function parameter both
-an input and output value.  This combines the behavior of both the
-"INPUT" and "OUTPUT" methods described earlier.  Output values are
-returned in the form of a Python tuple.  To return a Python list,
-using L_INOUT instead.
-
-         int            *INOUT
-         short          *INOUT
-         long           *INOUT
-         unsigned int   *INOUT
-         unsigned short *INOUT
-         unsigned long  *INOUT
-         unsigned char  *INOUT
-         float          *INOUT
-         double         *INOUT
-
-For example, suppose you were trying to wrap the following function :
-
-        void neg(double *x) {
-             *x = -(*x);
-        }
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        void neg(double *INOUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *INOUT { double *x };
-        void neg(double *x);
-
-Unlike C, this mapping does not directly modify the input value (since
-this makes no sense in Python).  Rather, the modified input value shows
-up as the return value of the function.  Thus, to apply this function
-to a Python variable you might do this :
-
-       x = neg(x)
-
-Note : previous versions of SWIG used the symbol 'BOTH' to mark
-input/output arguments.   This is still supported, but will be slowly
-phased out in future releases.
-%}
-
-#endif
-
-%typemap(python,in) int *INOUT = int *INPUT;
-%typemap(python,in) short *INOUT = short *INPUT;
-%typemap(python,in) long *INOUT = long *INPUT;
-%typemap(python,in) unsigned *INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *INOUT = unsigned char *INPUT;
-%typemap(python,in) float *INOUT = float *INPUT;
-%typemap(python,in) double *INOUT = double *INPUT;
-
-%typemap(python,argout) int *INOUT = int *OUTPUT;
-%typemap(python,argout) short *INOUT = short *OUTPUT;
-%typemap(python,argout) long *INOUT = long *OUTPUT;
-%typemap(python,argout) unsigned *INOUT = unsigned *OUTPUT;
-%typemap(python,argout) unsigned short *INOUT = unsigned short *OUTPUT;
-%typemap(python,argout) unsigned long *INOUT = unsigned long *OUTPUT;
-%typemap(python,argout) unsigned char *INOUT = unsigned char *OUTPUT;
-%typemap(python,argout) float *INOUT = float *OUTPUT;
-%typemap(python,argout) double *INOUT = double *OUTPUT;
-
-%typemap(python,in) int *T_INOUT = int *INPUT;
-%typemap(python,in) short *T_INOUT = short *INPUT;
-%typemap(python,in) long *T_INOUT = long *INPUT;
-%typemap(python,in) unsigned *T_INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *T_INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *T_INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *T_INOUT = unsigned char *INPUT;
-%typemap(python,in) float *T_INOUT = float *INPUT;
-%typemap(python,in) double *T_INOUT = double *INPUT;
-
-%typemap(python,argout) int *T_INOUT = int *T_OUTPUT;
-%typemap(python,argout) short *T_INOUT = short *T_OUTPUT;
-%typemap(python,argout) long *T_INOUT = long *T_OUTPUT;
-%typemap(python,argout) unsigned *T_INOUT = unsigned *T_OUTPUT;
-%typemap(python,argout) unsigned short *T_INOUT = unsigned short *T_OUTPUT;
-%typemap(python,argout) unsigned long *T_INOUT = unsigned long *T_OUTPUT;
-%typemap(python,argout) unsigned char *T_INOUT = unsigned char *T_OUTPUT;
-%typemap(python,argout) float *T_INOUT = float *T_OUTPUT;
-%typemap(python,argout) double *T_INOUT = double *T_OUTPUT;
-
-%typemap(python,in) int *L_INOUT = int *INPUT;
-%typemap(python,in) short *L_INOUT = short *INPUT;
-%typemap(python,in) long *L_INOUT = long *INPUT;
-%typemap(python,in) unsigned *L_INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *L_INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *L_INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *L_INOUT = unsigned char *INPUT;
-%typemap(python,in) float *L_INOUT = float *INPUT;
-%typemap(python,in) double *L_INOUT = double *INPUT;
-
-%typemap(python,argout) int *L_INOUT = int *L_OUTPUT;
-%typemap(python,argout) short *L_INOUT = short *L_OUTPUT;
-%typemap(python,argout) long *L_INOUT = long *L_OUTPUT;
-%typemap(python,argout) unsigned *L_INOUT = unsigned *L_OUTPUT;
-%typemap(python,argout) unsigned short *L_INOUT = unsigned short *L_OUTPUT;
-%typemap(python,argout) unsigned long *L_INOUT = unsigned long *L_OUTPUT;
-%typemap(python,argout) unsigned char *L_INOUT = unsigned char *L_OUTPUT;
-%typemap(python,argout) float *L_INOUT = float *L_OUTPUT;
-%typemap(python,argout) double *L_INOUT = double *L_OUTPUT;
-
-// Backwards compatibility
-
-%typemap(python,in) int *BOTH = int *INOUT;
-%typemap(python,in) short *BOTH = short *INOUT;
-%typemap(python,in) long *BOTH = long *INOUT;
-%typemap(python,in) unsigned *BOTH = unsigned *INOUT;
-%typemap(python,in) unsigned short *BOTH = unsigned short *INOUT;
-%typemap(python,in) unsigned long *BOTH = unsigned long *INOUT;
-%typemap(python,in) unsigned char *BOTH = unsigned char *INOUT;
-%typemap(python,in) float *BOTH = float *INOUT;
-%typemap(python,in) double *BOTH = double *INOUT;
-
-%typemap(python,argout) int *BOTH = int *INOUT;
-%typemap(python,argout) short *BOTH = short *INOUT;
-%typemap(python,argout) long *BOTH = long *INOUT;
-%typemap(python,argout) unsigned *BOTH = unsigned *INOUT;
-%typemap(python,argout) unsigned short *BOTH = unsigned short *INOUT;
-%typemap(python,argout) unsigned long *BOTH = unsigned long *INOUT;
-%typemap(python,argout) unsigned char *BOTH = unsigned char *INOUT;
-%typemap(python,argout) float *BOTH = float *INOUT;
-%typemap(python,argout) double *BOTH = double *INOUT;
-
-%typemap(python,in) int *T_BOTH = int *T_INOUT;
-%typemap(python,in) short *T_BOTH = short *T_INOUT;
-%typemap(python,in) long *T_BOTH = long *T_INOUT;
-%typemap(python,in) unsigned *T_BOTH = unsigned *T_INOUT;
-%typemap(python,in) unsigned short *T_BOTH = unsigned short *T_INOUT;
-%typemap(python,in) unsigned long *T_BOTH = unsigned long *T_INOUT;
-%typemap(python,in) unsigned char *T_BOTH = unsigned char *T_INOUT;
-%typemap(python,in) float *T_BOTH = float *T_INOUT;
-%typemap(python,in) double *T_BOTH = double *T_INOUT;
-
-%typemap(python,argout) int *T_BOTH = int *T_INOUT;
-%typemap(python,argout) short *T_BOTH = short *T_INOUT;
-%typemap(python,argout) long *T_BOTH = long *T_INOUT;
-%typemap(python,argout) unsigned *T_BOTH = unsigned *T_INOUT;
-%typemap(python,argout) unsigned short *T_BOTH = unsigned short *T_INOUT;
-%typemap(python,argout) unsigned long *T_BOTH = unsigned long *T_INOUT;
-%typemap(python,argout) unsigned char *T_BOTH = unsigned char *T_INOUT;
-%typemap(python,argout) float *T_BOTH = float *T_INOUT;
-%typemap(python,argout) double *T_BOTH = double *T_INOUT;
-
-// --------------------------------------------------------------------
-// Special types
-//
-// --------------------------------------------------------------------
-
-#ifdef AUTODOC
-%subsection "Special Methods"
-
-%text %{
-The typemaps.i library also provides the following mappings :
-
-PyObject *
-
-      When a PyObject * appears as either an input value or return
-      value of a function, SWIG passes it through unmodified.  Thus,
-      if you want to write a C function that operates on PyObjects,
-      it is easy to write.  For example :
-
-           %include typemaps.i
-           PyObject *spam(PyObject *obj1, int n);
-
-      Unlike normal Python wrapper functions, These functions can
-      use any combination of parameters that you wish.
-
-%}
-
-#endif
-
-
-// If a PyObject * appears as either an argument or a function return
-// value, simply pass it straight through.
-
-%typemap(python,in) PyObject * {
-  $target = $source;
-}
-
-%typemap(python,out) PyObject * {
-  $target = $source;
-}
-

wxPython/b

@@ -1,53 +0,0 @@
-#!/bin/sh
-
-if [ "$1" = "15" ]; then
-    PYVER=1.5
-    shift
-elif [ "$1" = "20" ]; then
-    PYVER=2.0
-    shift
-fi
-
-
-SETUP="python$PYVER -u setup.py"
-FLAGS="USE_SWIG=1 IN_CVS_TREE=1"
-OTHERFLAGS=""
-
-
-
-# "c" --> clean
-if [ "$1" =  "c" ]; then
-    shift
-    CMD="$SETUP $FLAGS $OTHERFLAGS clean"
-    OTHERCMD="rm -f wxPython/*.so"
-
-# "i" --> install
-elif [ "$1" = "i" ]; then
-    shift
-    CMD="$SETUP build $OTHERFLAGS install"
-
-# "s" --> source dist
-elif [ "$1" = "s" ]; then
-    shift
-    CMD="$SETUP $OTHERFLAGS sdist"
-
-# "r" --> rpm dist
-elif [ "$1" = "r" ]; then
-    shift
-    CMD="$SETUP $OTHERFLAGS bdist_rpm"
-
-# (no command arg) --> normal build for development
-else
-    CMD="$SETUP $FLAGS $OTHERFLAGS build_ext --inplace $*"
-fi
-
-
-echo $CMD
-$CMD
-
-
-if [ "$OTHERCMD" != "" ]; then
-    echo $OTHERCMD
-    $OTHERCMD
-fi
-

wxPython/b.bat

@@ -1,62 +0,0 @@
-@echo off
-setlocal
-
-set FLAGS=USE_SWIG=1 IN_CVS_TREE=1
-
-
-rem  Use non-default python?
-iff "%1" == "15" .or. "%1" == "20" then
-	set SETUP=c:\tools\python%1%\python.exe -u setup.py
-	shift
-else
-	set SETUP=python -u setup.py
-endiff
-
-
-
-rem "c" --> clean
-iff "%1" == "c" then
-	shift
-	set CMD=%SETUP% %FLAGS% clean
-	set OTHERCMD=del wxPython\*.pyd
-
-rem just remove the *.pyd's
-elseiff "%1" == "d" then
-	shift
-	set CMD=del wxPython\*.pyd
-
-rem "i" --> install
-elseiff "%1" == "i" then
-	shift
-	set CMD=%SETUP% build install
-
-rem "s" --> source dist
-elseiff "%1" == "s" then
-	shift
-	set CMD=%SETUP sdist
-
-rem "f" --> FINAL
-elseiff "%1" == "f" then
-	shift
-	set CMD=%SETUP% %FLAGS% FINAL=1 build_ext --inplace %1 %2 %3 %4 %5 %6 %7 %8 %9
-
-rem "h" --> HYBRID
-elseiff "%1" == "h" then
-	shift
-	set CMD=%SETUP% %FLAGS% HYBRID=1 build_ext --inplace %1 %2 %3 %4 %5 %6 %7 %8 %9
-
-rem (no command arg) --> normal build for development
-else
-	set CMD=%SETUP% %FLAGS% HYBRID=0 build_ext --inplace --debug %1 %2 %3 %4 %5 %6 %7 %8 %9
-endiff
-
-
-
-echo %CMD%
-%CMD%
-
-iff "%OTHERCMD%" != "" then
-	echo %OTHERCMD%
-	%OTHERCMD%
-endiff
-

wxPython/contrib/.cvsignore

@@ -1 +0,0 @@
-update.log

wxPython/contrib/README

@@ -1,3 +0,0 @@
-These sub directories contain add-on modules that are not part of the
-core wxPython, either because of licensing issues, optional code in
-wxWindows, contrib code in wxWindows, or whatever.

wxPython/contrib/glcanvas/.cvsignore

@@ -1,14 +0,0 @@
-
-*.exp
-*.lib
-*.obj
-*.pch
-Makefile
-Makefile.pre
-Setup
-build.local
-config.c
-glcanvas.h
-glcanvasc.ilk
-glcanvasc.pyd
-sedscript

wxPython/contrib/glcanvas/glcanvas.i

@@ -1,128 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        glcanvas.i
-// Purpose:     SWIG definitions for the OpenGL wxWindows classes
-//
-// Author:      Robin Dunn
-//
-// Created:     15-Mar-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module glcanvas
-
-%{
-#include "helpers.h"
-#include <wx/glcanvas.h>
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern windows2.i
-%extern windows3.i
-%extern frames.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-%extern controls.i
-%extern events.i
-
-
-%{
-#if defined(__WXMSW__)
-    static wxString wxPyEmptyStr("");
-    static wxPoint  wxPyDefaultPosition(-1, -1);
-    static wxSize   wxPyDefaultSize(-1, -1);
-#endif
-%}
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-
-class wxPalette;
-class wxWindow;
-class wxSize;
-class wxPoint;
-class wxGLCanvas;
-
-//---------------------------------------------------------------------------
-
-class wxGLContext {
-public:
-    wxGLContext(bool isRGB, wxGLCanvas *win, const wxPalette& palette = wxNullPalette);
-    ~wxGLContext();
-
-    void SetCurrent();
-    void SetColour(const char *colour);
-    void SwapBuffers();
-
-#ifdef __WXGTK__
-    void SetupPixelFormat();
-    void SetupPalette(const wxPalette& palette);
-    wxPalette CreateDefaultPalette();
-    wxPalette* GetPalette();
-#endif
-
-    wxWindow* GetWindow();
-};
-
-//---------------------------------------------------------------------------
-
-%typemap(python, in) int *attribList (int *temp) {
-    int i;
-    if (PySequence_Check($source)) {
-        int size = PyObject_Length($source);
-        temp = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
-        for (i = 0; i < size; i++) {
-            temp[i] = PyInt_AsLong(PySequence_GetItem($source, i));
-        }
-        temp[size] = 0;
-        $target = temp;
-    }
-}
-
-%typemap(python, freearg) int *attribList
-{
-    delete [] $source;
-}
-
-
-
-class wxGLCanvas : public wxScrolledWindow {
-public:
-    wxGLCanvas(wxWindow *parent, wxWindowID id = -1,
-               const wxPoint& pos = wxPyDefaultPosition,
-               const wxSize& size = wxPyDefaultSize, long style = 0,
-               const char* name = "GLCanvas",
-               int *attribList = NULL,
-               const wxPalette& palette = wxNullPalette);
-
-    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
-
-    void SetCurrent();
-    void SetColour(const char *colour);
-    void SwapBuffers();
-
-    wxGLContext* GetContext();
-};
-
-
-//---------------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-%}
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------

wxPython/contrib/glcanvas/gtk/.cvsignore

@@ -1,2 +0,0 @@
-*~
-_glcanvas.cpp

wxPython/contrib/glcanvas/gtk/glcanvas.py

@@ -1,123 +0,0 @@
-# This file was created automatically by SWIG.
-import glcanvasc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-import wx
-class wxGLContextPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,glcanvasc=glcanvasc):
-        if self.thisown == 1 :
-            glcanvasc.delete_wxGLContext(self)
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def SetupPixelFormat(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetupPixelFormat,(self,) + _args, _kwargs)
-        return val
-    def SetupPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetupPalette,(self,) + _args, _kwargs)
-        return val
-    def CreateDefaultPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_CreateDefaultPalette,(self,) + _args, _kwargs)
-        if val: val = wxPalettePtr(val) ; val.thisown = 1
-        return val
-    def GetPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetPalette,(self,) + _args, _kwargs)
-        if val: val = wxPalettePtr(val) 
-        return val
-    def GetWindow(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetWindow,(self,) + _args, _kwargs)
-        if val: val = wxWindowPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxGLContext instance at %s>" % (self.this,)
-class wxGLContext(wxGLContextPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLContext,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxGLCanvasPtr(wxScrolledWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def GetContext(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_GetContext,(self,) + _args, _kwargs)
-        if val: val = wxGLContextPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxGLCanvas instance at %s>" % (self.this,)
-class wxGLCanvas(wxGLCanvasPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLCanvas,_args,_kwargs)
-        self.thisown = 1
-        #wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/glcanvas/msw/.cvsignore

@@ -1 +0,0 @@
-*~

wxPython/contrib/glcanvas/msw/glcanvas.py

@@ -1,109 +0,0 @@
-# This file was created automatically by SWIG.
-import glcanvasc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-import wx
-class wxGLContextPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,glcanvasc=glcanvasc):
-        if self.thisown == 1 :
-            glcanvasc.delete_wxGLContext(self)
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def GetWindow(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetWindow,(self,) + _args, _kwargs)
-        if val: val = wxWindowPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxGLContext instance at %s>" % (self.this,)
-class wxGLContext(wxGLContextPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLContext,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxGLCanvasPtr(wxScrolledWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def GetContext(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_GetContext,(self,) + _args, _kwargs)
-        if val: val = wxGLContextPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxGLCanvas instance at %s>" % (self.this,)
-class wxGLCanvas(wxGLCanvasPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLCanvas,_args,_kwargs)
-        self.thisown = 1
-        #wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/glcanvas/stub.cpp

@@ -1,24 +0,0 @@
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-
-
-#ifdef __cplusplus
-extern "C"
-#endif
-SWIGEXPORT(void) initglcanvasc() {
-}
-
-

wxPython/contrib/ogl/.cvsignore

@@ -1,6 +0,0 @@
-Makefile
-contrib
-oglc.exp
-oglc.ilk
-oglc.pch
-oglc.pyd

wxPython/contrib/ogl/README.txt

@@ -1,7 +0,0 @@
-Since OGL is not always bundled with distributions of wxWindows, in
-order for it to be a standard part of wxPython I need to bundle it
-here.  The contents of the contrib directory are copies of the
-relevant parts of the main contrib directory in wxWindows.  The
-build.py script in this directory will also build the needed files
-from there, so you no longer have to worry about aquiring and building
-additional libraries beyond wxWindows itself.

wxPython/contrib/ogl/_ogldefs.i

@@ -1,63 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        _ogldefs.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     27-Aug-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-//---------------------------------------------------------------------------
-
-
-class wxOGLConstraint;
-class wxBitmapShape;
-class wxDiagram;
-class wxDrawnShape;
-class wxCircleShape;
-class wxCompositeShape;
-class wxDividedShape;
-class wxDivisionShape;
-class wxEllipseShape;
-class wxLineShape;
-class wxPolygonShape;
-class wxRectangleShape;
-class wxPseudoMetaFile;
-class wxShape;
-class wxShapeCanvas;
-class wxShapeEvtHandler;
-class wxTextShape;
-class wxControlPoint;
-
-class wxPyOGLConstraint;
-class wxPyBitmapShape;
-class wxPyDiagram;
-class wxPyDrawnShape;
-class wxPyCircleShape;
-class wxPyCompositeShape;
-class wxPyDividedShape;
-class wxPyDivisionShape;
-class wxPyEllipseShape;
-class wxPyLineShape;
-class wxPyPolygonShape;
-class wxPyRectangleShape;
-class wxPyPseudoMetaFile;
-class wxPyShape;
-class wxPyShapeCanvas;
-class wxPyShapeEvtHandler;
-class wxPyTextShape;
-class wxPyControlPoint;
-
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-
-
-
-

wxPython/contrib/ogl/_oglextras.py

@@ -1,36 +0,0 @@
-
-wxShapeCanvas =       wxPyShapeCanvas
-wxShapeEvtHandler =   wxPyShapeEvtHandler
-wxShape =             wxPyShape
-wxRectangleShape =    wxPyRectangleShape
-wxBitmapShape =       wxPyBitmapShape
-wxDrawnShape =        wxPyDrawnShape
-wxCompositeShape =    wxPyCompositeShape
-wxDividedShape =      wxPyDividedShape
-wxDivisionShape =     wxPyDivisionShape
-wxEllipseShape =      wxPyEllipseShape
-wxCircleShape =       wxPyCircleShape
-wxLineShape =         wxPyLineShape
-wxPolygonShape =      wxPyPolygonShape
-wxTextShape =         wxPyTextShape
-wxControlPoint =      wxPyControlPoint
-
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-import wx
-wx.wxPyShapeCanvasPtr     = wxPyShapeCanvasPtr
-wx.wxPyShapeEvtHandlerPtr = wxPyShapeEvtHandlerPtr
-wx.wxPyShapePtr           = wxPyShapePtr
-wx.wxPyRectangleShapePtr  = wxPyRectangleShapePtr
-wx.wxPyBitmapShapePtr     = wxPyBitmapShapePtr
-wx.wxPyDrawnShapePtr      = wxPyDrawnShapePtr
-wx.wxPyCompositeShapePtr  = wxPyCompositeShapePtr
-wx.wxPyDividedShapePtr    = wxPyDividedShapePtr
-wx.wxPyDivisionShapePtr   = wxPyDivisionShapePtr
-wx.wxPyEllipseShapePtr    = wxPyEllipseShapePtr
-wx.wxPyCircleShapePtr     = wxPyCircleShapePtr
-wx.wxPyLineShapePtr       = wxPyLineShapePtr
-wx.wxPyPolygonShapePtr    = wxPyPolygonShapePtr
-wx.wxPyTextShapePtr       = wxPyTextShapePtr
-wx.wxShapeRegionPtr       = wxShapeRegionPtr
-wx.wxOGLConstraintPtr     = wxOGLConstraintPtr
-wx.wxControlPointPtr      = wxPyControlPointPtr

wxPython/contrib/ogl/ogl.cpp

@@ -1,801 +0,0 @@
-/*
- * FILE : contrib/ogl/ogl.cpp
- * 
- * This file was automatically generated by :
- * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Build 883)
- * 
- * 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) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif
-#define SWIG_init    initoglc
-
-#define SWIG_name    "oglc"
-
-#include "helpers.h"
-#include "oglhelpers.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;
-}
-
-static char* wxStringErrorMsg = "string type is required for parameter";
-
-extern "C" SWIGEXPORT(void) initoglbasicc();
-extern "C" SWIGEXPORT(void) initoglshapesc();
-extern "C" SWIGEXPORT(void) initoglshapes2c();
-extern "C" SWIGEXPORT(void) initoglcanvasc();
-#ifdef __cplusplus
-extern "C" {
-#endif
-static PyObject *_wrap_wxOGLInitialize(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    char *_kwnames[] = {  NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxOGLInitialize",_kwnames)) 
-        return NULL;
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxOGLInitialize();
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-static PyObject *_wrap_wxOGLCleanUp(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    char *_kwnames[] = {  NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxOGLCleanUp",_kwnames)) 
-        return NULL;
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxOGLCleanUp();
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-static PyMethodDef oglcMethods[] = {
-	 { "wxOGLCleanUp", (PyCFunction) _wrap_wxOGLCleanUp, METH_VARARGS | METH_KEYWORDS },
-	 { "wxOGLInitialize", (PyCFunction) _wrap_wxOGLInitialize, METH_VARARGS | METH_KEYWORDS },
-	 { NULL, NULL }
-};
-#ifdef __cplusplus
-}
-#endif
-/*
- * This table is used by the pointer type-checker
- */
-static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
-    { "_wxAcceleratorTable","_class_wxAcceleratorTable",0},
-    { "_wxEvent","_class_wxEvent",0},
-    { "_class_wxActivateEvent","_wxActivateEvent",0},
-    { "_signed_long","_long",0},
-    { "_wxMenuEvent","_class_wxMenuEvent",0},
-    { "_class_wxProcessEvent","_wxProcessEvent",0},
-    { "_class_wxJPEGHandler","_wxJPEGHandler",0},
-    { "_class_wxFSFile","_wxFSFile",0},
-    { "_wxPyBitmapDataObject","_class_wxPyBitmapDataObject",0},
-    { "_wxBitmapDataObject","_class_wxBitmapDataObject",0},
-    { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
-    { "_wxBMPHandler","_class_wxBMPHandler",0},
-    { "_wxImage","_class_wxImage",0},
-    { "_wxFlexGridSizer","_class_wxFlexGridSizer",0},
-    { "_wxWindowDisabler","_class_wxWindowDisabler",0},
-    { "_class_wxDateTime","_wxDateTime",0},
-    { "_wxPrintQuality","_wxCoord",0},
-    { "_wxPrintQuality","_int",0},
-    { "_wxPrintQuality","_signed_int",0},
-    { "_wxPrintQuality","_unsigned_int",0},
-    { "_wxPrintQuality","_wxWindowID",0},
-    { "_wxPrintQuality","_uint",0},
-    { "_wxPrintQuality","_EBool",0},
-    { "_wxPrintQuality","_size_t",0},
-    { "_wxPrintQuality","_time_t",0},
-    { "_class_wxCustomDataObject","_wxCustomDataObject",0},
-    { "_wxSpinCtrl","_class_wxSpinCtrl",0},
-    { "_wxFontData","_class_wxFontData",0},
-    { "_class_wxRegionIterator","_wxRegionIterator",0},
-    { "_class_wxPyTextDropTarget","_wxPyTextDropTarget",0},
-    { "_class_wxMenuBar","_wxMenuBar",0},
-    { "_class_wxPyTreeItemData","_wxPyTreeItemData",0},
-    { "_class_wxStaticBoxSizer","_wxStaticBoxSizer",0},
-    { "_class_wxEvtHandler","_wxEvtHandler",0},
-    { "_wxPaintEvent","_class_wxPaintEvent",0},
-    { "_wxGIFHandler","_class_wxGIFHandler",0},
-    { "_wxPySizer","_class_wxPySizer",0},
-    { "_wxInternetFSHandler","_class_wxInternetFSHandler",0},
-    { "_wxPyCompositeShape","_class_wxPyCompositeShape",0},
-    { "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
-    { "_wxCursor","_class_wxCursor",0},
-    { "_wxNotifyEvent","_class_wxNotifyEvent",0},
-    { "_wxPyProcess","_class_wxPyProcess",0},
-    { "_wxPyTreeCtrl","_class_wxPyTreeCtrl",0},
-    { "_wxImageHandler","_class_wxImageHandler",0},
-    { "_class_wxPyRectangleShape","_wxPyRectangleShape",0},
-    { "_wxLog","_class_wxLog",0},
-    { "_class_wxToolBarBase","_wxToolBarBase",0},
-    { "_wxMask","_class_wxMask",0},
-    { "_wxToolTip","_class_wxToolTip",0},
-    { "_wxPNGHandler","_class_wxPNGHandler",0},
-    { "_class_wxOGLConstraint","_wxOGLConstraint",0},
-    { "_class_wxColourData","_wxColourData",0},
-    { "_class_wxPageSetupDialogData","_wxPageSetupDialogData",0},
-    { "_wxPrinter","_class_wxPrinter",0},
-    { "_wxPseudoMetaFile","_class_wxPseudoMetaFile",0},
-    { "_class_wxArrowHead","_wxArrowHead",0},
-    { "_wxPen","_class_wxPen",0},
-    { "_wxUpdateUIEvent","_class_wxUpdateUIEvent",0},
-    { "_class_wxNotebookSizer","_wxNotebookSizer",0},
-    { "_byte","_unsigned_char",0},
-    { "_wxDataObject","_class_wxDataObject",0},
-    { "_class_wxPyFontEnumerator","_wxPyFontEnumerator",0},
-    { "_wxStaticBox","_class_wxStaticBox",0},
-    { "_wxPyDataObjectSimple","_class_wxPyDataObjectSimple",0},
-    { "_wxPyDropSource","_class_wxPyDropSource",0},
-    { "_wxChoice","_class_wxChoice",0},
-    { "_wxSlider","_class_wxSlider",0},
-    { "_wxNotebookEvent","_class_wxNotebookEvent",0},
-    { "_wxPyPrintout","_class_wxPyPrintout",0},
-    { "_wxShapeRegion","_class_wxShapeRegion",0},
-    { "_long","_unsigned_long",0},
-    { "_long","_signed_long",0},
-    { "_wxImageList","_class_wxImageList",0},
-    { "_wxDataObjectSimple","_class_wxDataObjectSimple",0},
-    { "_wxDropFilesEvent","_class_wxDropFilesEvent",0},
-    { "_wxBitmapButton","_class_wxBitmapButton",0},
-    { "_wxSashWindow","_class_wxSashWindow",0},
-    { "_class_wxSizer","_wxSizer",0},
-    { "_class_wxTIFFHandler","_wxTIFFHandler",0},
-    { "_class_wxPrintDialogData","_wxPrintDialogData",0},
-    { "_wxGridSizer","_class_wxGridSizer",0},
-    { "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
-    { "_class_wxClipboard","_wxClipboard",0},
-    { "_class_wxGauge","_wxGauge",0},
-    { "_class_wxSashEvent","_wxSashEvent",0},
-    { "_wxDC","_class_wxDC",0},
-    { "_wxSizerItem","_class_wxSizerItem",0},
-    { "_class_wxBitmapDataObject","_wxBitmapDataObject",0},
-    { "_wxListEvent","_class_wxListEvent",0},
-    { "_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0},
-    { "_wxProgressDialog","_class_wxProgressDialog",0},
-    { "_class_wxBMPHandler","_wxBMPHandler",0},
-    { "_wxPrintPreview","_class_wxPrintPreview",0},
-    { "_class_wxFlexGridSizer","_wxFlexGridSizer",0},
-    { "_wxSpinEvent","_class_wxSpinEvent",0},
-    { "_wxSashLayoutWindow","_class_wxSashLayoutWindow",0},
-    { "_wxPyBitmapShape","_class_wxPyBitmapShape",0},
-    { "_class_wxPyEllipseShape","_wxPyEllipseShape",0},
-    { "_size_t","_wxCoord",0},
-    { "_size_t","_wxPrintQuality",0},
-    { "_size_t","_time_t",0},
-    { "_size_t","_unsigned_int",0},
-    { "_size_t","_int",0},
-    { "_size_t","_wxWindowID",0},
-    { "_size_t","_uint",0},
-    { "_class_wxRealPoint","_wxRealPoint",0},
-    { "_wxNavigationKeyEvent","_class_wxNavigationKeyEvent",0},
-    { "_wxPNMHandler","_class_wxPNMHandler",0},
-    { "_wxWindowCreateEvent","_class_wxWindowCreateEvent",0},
-    { "_wxLogGui","_class_wxLogGui",0},
-    { "_class_wxPyShapeEvtHandler","_wxPyShapeEvtHandler",0},
-    { "_class_wxMenuItem","_wxMenuItem",0},
-    { "_class_wxPaintEvent","_wxPaintEvent",0},
-    { "_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0},
-    { "_class_wxStatusBar","_wxStatusBar",0},
-    { "_class_wxGIFHandler","_wxGIFHandler",0},
-    { "_class_wxPySizer","_wxPySizer",0},
-    { "_class_wxPyCompositeShape","_wxPyCompositeShape",0},
-    { "_wxPyPolygonShape","_class_wxPyPolygonShape",0},
-    { "_class_wxPostScriptDC","_wxPostScriptDC",0},
-    { "_wxPanel","_class_wxPanel",0},
-    { "_wxInitDialogEvent","_class_wxInitDialogEvent",0},
-    { "_wxCheckBox","_class_wxCheckBox",0},
-    { "_class_wxPyTreeCtrl","_wxPyTreeCtrl",0},
-    { "_wxPyEvent","_class_wxPyEvent",0},
-    { "_wxTextCtrl","_class_wxTextCtrl",0},
-    { "_class_wxMask","_wxMask",0},
-    { "_wxTextDataObject","_class_wxTextDataObject",0},
-    { "_class_wxKeyEvent","_wxKeyEvent",0},
-    { "_class_wxToolTip","_wxToolTip",0},
-    { "_class_wxPNGHandler","_wxPNGHandler",0},
-    { "_wxFileConfig","_class_wxFileConfig",0},
-    { "_wxColour","_class_wxColour",0},
-    { "_class_wxDialog","_wxDialog",0},
-    { "_wxBusyCursor","_class_wxBusyCursor",0},
-    { "_wxPageSetupDialog","_class_wxPageSetupDialog",0},
-    { "_class_wxPrinter","_wxPrinter",0},
-    { "_class_wxFileDataObject","_wxFileDataObject",0},
-    { "_wxIdleEvent","_class_wxIdleEvent",0},
-    { "_class_wxUpdateUIEvent","_wxUpdateUIEvent",0},
-    { "_wxToolBar","_class_wxToolBar",0},
-    { "_class_wxDataObject","_wxDataObject",0},
-    { "_wxCaret","_class_wxCaret",0},
-    { "_wxStaticLine","_class_wxStaticLine",0},
-    { "_class_wxLayoutAlgorithm","_wxLayoutAlgorithm",0},
-    { "_wxBrush","_class_wxBrush",0},
-    { "_wxMiniFrame","_class_wxMiniFrame",0},
-    { "_class_wxNotebookEvent","_wxNotebookEvent",0},
-    { "_class_wxPyPrintout","_wxPyPrintout",0},
-    { "_wxDataFormat","_class_wxDataFormat",0},
-    { "_class_wxDataObjectSimple","_wxDataObjectSimple",0},
-    { "_class_wxSashWindow","_wxSashWindow",0},
-    { "_wxShowEvent","_class_wxShowEvent",0},
-    { "_class_wxPyDivisionShape","_wxPyDivisionShape",0},
-    { "_uint","_wxCoord",0},
-    { "_uint","_wxPrintQuality",0},
-    { "_uint","_time_t",0},
-    { "_uint","_size_t",0},
-    { "_uint","_unsigned_int",0},
-    { "_uint","_int",0},
-    { "_uint","_wxWindowID",0},
-    { "_wxChar","_char",0},
-    { "_wxPyValidator","_class_wxPyValidator",0},
-    { "_class_wxEvent","_wxEvent",0},
-    { "_wxCheckListBox","_class_wxCheckListBox",0},
-    { "_wxSplitterEvent","_class_wxSplitterEvent",0},
-    { "_wxRect","_class_wxRect",0},
-    { "_wxCommandEvent","_class_wxCommandEvent",0},
-    { "_wxPyShapeCanvas","_class_wxPyShapeCanvas",0},
-    { "_wxSizeEvent","_class_wxSizeEvent",0},
-    { "_class_wxLogWindow","_wxLogWindow",0},
-    { "_class_wxImage","_wxImage",0},
-    { "_wxPoint","_class_wxPoint",0},
-    { "_class_wxWindowDisabler","_wxWindowDisabler",0},
-    { "_class_wxSashLayoutWindow","_wxSashLayoutWindow",0},
-    { "_class_wxPyBitmapShape","_wxPyBitmapShape",0},
-    { "_class_wxButton","_wxButton",0},
-    { "_wxRadioBox","_class_wxRadioBox",0},
-    { "_class_wxSpinCtrl","_wxSpinCtrl",0},
-    { "_class_wxFontData","_wxFontData",0},
-    { "_class_wxPNMHandler","_wxPNMHandler",0},
-    { "_wxBoxSizer","_class_wxBoxSizer",0},
-    { "_class_wxZipFSHandler","_wxZipFSHandler",0},
-    { "_char","_wxChar",0},
-    { "_wxBitmap","_class_wxBitmap",0},
-    { "_wxPrintDialog","_class_wxPrintDialog",0},
-    { "_wxPyControlPoint","_class_wxPyControlPoint",0},
-    { "_wxWindowDC","_class_wxWindowDC",0},
-    { "_wxTimerEvent","_class_wxTimerEvent",0},
-    { "_wxPyTimer","_class_wxPyTimer",0},
-    { "_wxScrollBar","_class_wxScrollBar",0},
-    { "_wxSpinButton","_class_wxSpinButton",0},
-    { "_wxColourDialog","_class_wxColourDialog",0},
-    { "_wxPrintData","_class_wxPrintData",0},
-    { "_class_wxInternetFSHandler","_wxInternetFSHandler",0},
-    { "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
-    { "_class_wxNotifyEvent","_wxNotifyEvent",0},
-    { "_wxMessageDialog","_class_wxMessageDialog",0},
-    { "_class_wxValidator","_wxValidator",0},
-    { "_class_wxPyEvent","_wxPyEvent",0},
-    { "_wxTextEntryDialog","_class_wxTextEntryDialog",0},
-    { "_wxConfig","_class_wxConfig",0},
-    { "_class_wxIconizeEvent","_wxIconizeEvent",0},
-    { "_class_wxStaticBitmap","_wxStaticBitmap",0},
-    { "_class_wxFileConfig","_wxFileConfig",0},
-    { "_class_wxPyDrawnShape","_wxPyDrawnShape",0},
-    { "_class_wxBusyCursor","_wxBusyCursor",0},
-    { "_wxToolBarSimple","_class_wxToolBarSimple",0},
-    { "_wxMDIChildFrame","_class_wxMDIChildFrame",0},
-    { "_wxListItem","_class_wxListItem",0},
-    { "_class_wxPseudoMetaFile","_wxPseudoMetaFile",0},
-    { "_class_wxToolBar","_wxToolBar",0},
-    { "_wxDropTarget","_class_wxDropTarget",0},
-    { "_class_wxStaticLine","_wxStaticLine",0},
-    { "_wxScrollEvent","_class_wxScrollEvent",0},
-    { "_wxToolBarToolBase","_class_wxToolBarToolBase",0},
-    { "_wxCalculateLayoutEvent","_class_wxCalculateLayoutEvent",0},
-    { "_class_wxMemoryFSHandler","_wxMemoryFSHandler",0},
-    { "_class_wxShapeRegion","_wxShapeRegion",0},
-    { "_EBool","_wxCoord",0},
-    { "_EBool","_wxPrintQuality",0},
-    { "_EBool","_signed_int",0},
-    { "_EBool","_int",0},
-    { "_EBool","_wxWindowID",0},
-    { "_class_wxRegion","_wxRegion",0},
-    { "_class_wxDataFormat","_wxDataFormat",0},
-    { "_class_wxDropFilesEvent","_wxDropFilesEvent",0},
-    { "_wxWindowDestroyEvent","_class_wxWindowDestroyEvent",0},
-    { "_class_wxPreviewFrame","_wxPreviewFrame",0},
-    { "_wxStaticText","_class_wxStaticText",0},
-    { "_wxFont","_class_wxFont",0},
-    { "_class_wxPyDropTarget","_wxPyDropTarget",0},
-    { "_wxCloseEvent","_class_wxCloseEvent",0},
-    { "_class_wxSplitterEvent","_wxSplitterEvent",0},
-    { "_wxProcessEvent","_class_wxProcessEvent",0},
-    { "_wxNotebook","_class_wxNotebook",0},
-    { "_wxFSFile","_class_wxFSFile",0},
-    { "_unsigned_long","_long",0},
-    { "_class_wxRect","_wxRect",0},
-    { "_class_wxDC","_wxDC",0},
-    { "_wxScrollWinEvent","_class_wxScrollWinEvent",0},
-    { "_wxPyCircleShape","_class_wxPyCircleShape",0},
-    { "_class_wxPyShapeCanvas","_wxPyShapeCanvas",0},
-    { "_wxGenericDragImage","_class_wxGenericDragImage",0},
-    { "_class_wxProgressDialog","_wxProgressDialog",0},
-    { "_wxQueryNewPaletteEvent","_class_wxQueryNewPaletteEvent",0},
-    { "_wxPyInputStream","_class_wxPyInputStream",0},
-    { "_wxPyApp","_class_wxPyApp",0},
-    { "_class_wxWindowCreateEvent","_wxWindowCreateEvent",0},
-    { "_class_wxOutputStream","_wxOutputStream",0},
-    { "_wxLogTextCtrl","_class_wxLogTextCtrl",0},
-    { "_wxMDIParentFrame","_class_wxMDIParentFrame",0},
-    { "_class_wxTreeEvent","_wxTreeEvent",0},
-    { "_class_wxDirDialog","_wxDirDialog",0},
-    { "_wxTimeSpan","_class_wxTimeSpan",0},
-    { "_wxPyLineShape","_class_wxPyLineShape",0},
-    { "_wxFocusEvent","_class_wxFocusEvent",0},
-    { "_wxMaximizeEvent","_class_wxMaximizeEvent",0},
-    { "_class_wxTimerEvent","_wxTimerEvent",0},
-    { "_class_wxPyTimer","_wxPyTimer",0},
-    { "_class_wxSpinButton","_wxSpinButton",0},
-    { "_class_wxPyPolygonShape","_wxPyPolygonShape",0},
-    { "_wxAcceleratorEntry","_class_wxAcceleratorEntry",0},
-    { "_class_wxPanel","_wxPanel",0},
-    { "_class_wxCheckBox","_wxCheckBox",0},
-    { "_wxComboBox","_class_wxComboBox",0},
-    { "_wxRadioButton","_class_wxRadioButton",0},
-    { "_class_wxMessageDialog","_wxMessageDialog",0},
-    { "_signed_int","_wxCoord",0},
-    { "_signed_int","_wxPrintQuality",0},
-    { "_signed_int","_EBool",0},
-    { "_signed_int","_wxWindowID",0},
-    { "_signed_int","_int",0},
-    { "_class_wxTextCtrl","_wxTextCtrl",0},
-    { "_class_wxListItemAttr","_wxListItemAttr",0},
-    { "_wxLayoutConstraints","_class_wxLayoutConstraints",0},
-    { "_class_wxTextDataObject","_wxTextDataObject",0},
-    { "_wxMenu","_class_wxMenu",0},
-    { "_class_wxMoveEvent","_wxMoveEvent",0},
-    { "_wxListBox","_class_wxListBox",0},
-    { "_wxScreenDC","_class_wxScreenDC",0},
-    { "_class_wxToolBarSimple","_wxToolBarSimple",0},
-    { "_class_wxMDIChildFrame","_wxMDIChildFrame",0},
-    { "_wxArrowHead","_class_wxArrowHead",0},
-    { "_WXTYPE","_wxDateTime_t",0},
-    { "_WXTYPE","_short",0},
-    { "_WXTYPE","_signed_short",0},
-    { "_WXTYPE","_unsigned_short",0},
-    { "_wxFileDialog","_class_wxFileDialog",0},
-    { "_class_wxDropTarget","_wxDropTarget",0},
-    { "_class_wxCaret","_wxCaret",0},
-    { "_class_wxMDIClientWindow","_wxMDIClientWindow",0},
-    { "_class_wxBrush","_wxBrush",0},
-    { "_wxTipProvider","_class_wxTipProvider",0},
-    { "_unsigned_short","_wxDateTime_t",0},
-    { "_unsigned_short","_WXTYPE",0},
-    { "_unsigned_short","_short",0},
-    { "_class_wxWindow","_wxWindow",0},
-    { "_class_wxLogStderr","_wxLogStderr",0},
-    { "_wxSplitterWindow","_class_wxSplitterWindow",0},
-    { "_wxDateSpan","_class_wxDateSpan",0},
-    { "_class_wxStaticText","_wxStaticText",0},
-    { "_wxPrintDialogData","_class_wxPrintDialogData",0},
-    { "_class_wxFont","_wxFont",0},
-    { "_wxClipboard","_class_wxClipboard",0},
-    { "_class_wxPyValidator","_wxPyValidator",0},
-    { "_class_wxCloseEvent","_wxCloseEvent",0},
-    { "_wxSashEvent","_class_wxSashEvent",0},
-    { "_wxBusyInfo","_class_wxBusyInfo",0},
-    { "_class_wxMenuEvent","_wxMenuEvent",0},
-    { "_wxPaletteChangedEvent","_class_wxPaletteChangedEvent",0},
-    { "_wxJoystick","_class_wxJoystick",0},
-    { "_class_wxPyBitmapDataObject","_wxPyBitmapDataObject",0},
-    { "_class_wxPyCircleShape","_wxPyCircleShape",0},
-    { "_wxClientDC","_class_wxClientDC",0},
-    { "_wxMouseEvent","_class_wxMouseEvent",0},
-    { "_class_wxGenericDragImage","_wxGenericDragImage",0},
-    { "_wxListCtrl","_class_wxListCtrl",0},
-    { "_wxSingleChoiceDialog","_class_wxSingleChoiceDialog",0},
-    { "_wxPyDividedShape","_class_wxPyDividedShape",0},
-    { "_class_wxPoint","_wxPoint",0},
-    { "_class_wxPyInputStream","_wxPyInputStream",0},
-    { "_wxRealPoint","_class_wxRealPoint",0},
-    { "_class_wxRadioBox","_wxRadioBox",0},
-    { "_class_wxBoxSizer","_wxBoxSizer",0},
-    { "_signed_short","_WXTYPE",0},
-    { "_signed_short","_short",0},
-    { "_wxMemoryDC","_class_wxMemoryDC",0},
-    { "_wxPyTextDataObject","_class_wxPyTextDataObject",0},
-    { "_class_wxPrintDialog","_wxPrintDialog",0},
-    { "_wxPyFileSystemHandler","_class_wxPyFileSystemHandler",0},
-    { "_class_wxPyControlPoint","_wxPyControlPoint",0},
-    { "_wxPaintDC","_class_wxPaintDC",0},
-    { "_class_wxWindowDC","_wxWindowDC",0},
-    { "_class_wxFocusEvent","_wxFocusEvent",0},
-    { "_class_wxMaximizeEvent","_wxMaximizeEvent",0},
-    { "_wxStatusBar","_class_wxStatusBar",0},
-    { "_class_wxAcceleratorEntry","_wxAcceleratorEntry",0},
-    { "_class_wxCursor","_wxCursor",0},
-    { "_wxPostScriptDC","_class_wxPostScriptDC",0},
-    { "_wxPyFileDropTarget","_class_wxPyFileDropTarget",0},
-    { "_class_wxPyProcess","_wxPyProcess",0},
-    { "_class_wxImageHandler","_wxImageHandler",0},
-    { "_wxPyShape","_class_wxPyShape",0},
-    { "_wxScrolledWindow","_class_wxScrolledWindow",0},
-    { "_class_wxLog","_wxLog",0},
-    { "_wxTreeItemId","_class_wxTreeItemId",0},
-    { "_unsigned_char","_byte",0},
-    { "_class_wxMenu","_wxMenu",0},
-    { "_wxControl","_class_wxControl",0},
-    { "_class_wxListBox","_wxListBox",0},
-    { "_unsigned_int","_wxCoord",0},
-    { "_unsigned_int","_wxPrintQuality",0},
-    { "_unsigned_int","_time_t",0},
-    { "_unsigned_int","_size_t",0},
-    { "_unsigned_int","_uint",0},
-    { "_unsigned_int","_wxWindowID",0},
-    { "_unsigned_int","_int",0},
-    { "_wxIcon","_class_wxIcon",0},
-    { "_wxDialog","_class_wxDialog",0},
-    { "_class_wxListItem","_wxListItem",0},
-    { "_class_wxPen","_wxPen",0},
-    { "_class_wxFileDialog","_wxFileDialog",0},
-    { "_wxQueryLayoutInfoEvent","_class_wxQueryLayoutInfoEvent",0},
-    { "_wxConfigBase","_class_wxConfigBase",0},
-    { "_short","_wxDateTime_t",0},
-    { "_short","_WXTYPE",0},
-    { "_short","_unsigned_short",0},
-    { "_short","_signed_short",0},
-    { "_class_wxStaticBox","_wxStaticBox",0},
-    { "_wxLayoutAlgorithm","_class_wxLayoutAlgorithm",0},
-    { "_wxPyTextShape","_class_wxPyTextShape",0},
-    { "_class_wxPyDataObjectSimple","_wxPyDataObjectSimple",0},
-    { "_class_wxPyDropSource","_wxPyDropSource",0},
-    { "_class_wxScrollEvent","_wxScrollEvent",0},
-    { "_wxJoystickEvent","_class_wxJoystickEvent",0},
-    { "_class_wxChoice","_wxChoice",0},
-    { "_class_wxSlider","_wxSlider",0},
-    { "_class_wxCalculateLayoutEvent","_wxCalculateLayoutEvent",0},
-    { "_class_wxImageList","_wxImageList",0},
-    { "_class_wxBitmapButton","_wxBitmapButton",0},
-    { "_wxFileSystemHandler","_class_wxFileSystemHandler",0},
-    { "_wxPyTipProvider","_class_wxPyTipProvider",0},
-    { "_wxFrame","_class_wxFrame",0},
-    { "_wxPCXHandler","_class_wxPCXHandler",0},
-    { "_class_wxGridSizer","_wxGridSizer",0},
-    { "_wxPyDivisionShape","_class_wxPyDivisionShape",0},
-    { "_class_wxPaletteChangedEvent","_wxPaletteChangedEvent",0},
-    { "_class_wxNotebook","_wxNotebook",0},
-    { "_wxJPEGHandler","_class_wxJPEGHandler",0},
-    { "_wxWindowID","_wxCoord",0},
-    { "_wxWindowID","_wxPrintQuality",0},
-    { "_wxWindowID","_time_t",0},
-    { "_wxWindowID","_size_t",0},
-    { "_wxWindowID","_EBool",0},
-    { "_wxWindowID","_uint",0},
-    { "_wxWindowID","_int",0},
-    { "_wxWindowID","_signed_int",0},
-    { "_wxWindowID","_unsigned_int",0},
-    { "_class_wxScrollWinEvent","_wxScrollWinEvent",0},
-    { "_class_wxSizerItem","_wxSizerItem",0},
-    { "_int","_wxCoord",0},
-    { "_int","_wxPrintQuality",0},
-    { "_int","_time_t",0},
-    { "_int","_size_t",0},
-    { "_int","_EBool",0},
-    { "_int","_uint",0},
-    { "_int","_wxWindowID",0},
-    { "_int","_unsigned_int",0},
-    { "_int","_signed_int",0},
-    { "_class_wxMouseEvent","_wxMouseEvent",0},
-    { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
-    { "_wxLogWindow","_class_wxLogWindow",0},
-    { "_class_wxListEvent","_wxListEvent",0},
-    { "_class_wxPrintPreview","_wxPrintPreview",0},
-    { "_wxDateTime_t","_unsigned_short",0},
-    { "_wxDateTime_t","_short",0},
-    { "_wxDateTime_t","_WXTYPE",0},
-    { "_class_wxSpinEvent","_wxSpinEvent",0},
-    { "_class_wxQueryNewPaletteEvent","_wxQueryNewPaletteEvent",0},
-    { "_wxDateTime","_class_wxDateTime",0},
-    { "_time_t","_wxCoord",0},
-    { "_time_t","_wxPrintQuality",0},
-    { "_time_t","_unsigned_int",0},
-    { "_time_t","_int",0},
-    { "_time_t","_wxWindowID",0},
-    { "_time_t","_uint",0},
-    { "_time_t","_size_t",0},
-    { "_class_wxNavigationKeyEvent","_wxNavigationKeyEvent",0},
-    { "_wxLogNull","_class_wxLogNull",0},
-    { "_wxButton","_class_wxButton",0},
-    { "_wxZipFSHandler","_class_wxZipFSHandler",0},
-    { "_class_wxPyApp","_wxPyApp",0},
-    { "_wxSize","_class_wxSize",0},
-    { "_wxRegionIterator","_class_wxRegionIterator",0},
-    { "_class_wxPyTextDataObject","_wxPyTextDataObject",0},
-    { "_class_wxLogTextCtrl","_wxLogTextCtrl",0},
-    { "_class_wxLogGui","_wxLogGui",0},
-    { "_class_wxMDIParentFrame","_wxMDIParentFrame",0},
-    { "_wxPyTreeItemData","_class_wxPyTreeItemData",0},
-    { "_wxStaticBoxSizer","_class_wxStaticBoxSizer",0},
-    { "_class_wxTimeSpan","_wxTimeSpan",0},
-    { "_class_wxPyFileSystemHandler","_wxPyFileSystemHandler",0},
-    { "_class_wxPyLineShape","_wxPyLineShape",0},
-    { "_class_wxPaintDC","_wxPaintDC",0},
-    { "_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0},
-    { "_class_wxPyFileDropTarget","_wxPyFileDropTarget",0},
-    { "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
-    { "_class_wxComboBox","_wxComboBox",0},
-    { "_class_wxRadioButton","_wxRadioButton",0},
-    { "_class_wxPyShape","_wxPyShape",0},
-    { "_wxValidator","_class_wxValidator",0},
-    { "_wxToolBarBase","_class_wxToolBarBase",0},
-    { "_class_wxTreeItemId","_wxTreeItemId",0},
-    { "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
-    { "_wxIconizeEvent","_class_wxIconizeEvent",0},
-    { "_class_wxControl","_wxControl",0},
-    { "_wxStaticBitmap","_class_wxStaticBitmap",0},
-    { "_wxPyDrawnShape","_class_wxPyDrawnShape",0},
-    { "_class_wxIcon","_wxIcon",0},
-    { "_class_wxColour","_wxColour",0},
-    { "_class_wxScreenDC","_wxScreenDC",0},
-    { "_class_wxPageSetupDialog","_wxPageSetupDialog",0},
-    { "_wxPalette","_class_wxPalette",0},
-    { "_class_wxIdleEvent","_wxIdleEvent",0},
-    { "_class_wxConfigBase","_wxConfigBase",0},
-    { "_wxCoord","_int",0},
-    { "_wxCoord","_signed_int",0},
-    { "_wxCoord","_unsigned_int",0},
-    { "_wxCoord","_wxWindowID",0},
-    { "_wxCoord","_uint",0},
-    { "_wxCoord","_EBool",0},
-    { "_wxCoord","_size_t",0},
-    { "_wxCoord","_time_t",0},
-    { "_wxCoord","_wxPrintQuality",0},
-    { "_wxEraseEvent","_class_wxEraseEvent",0},
-    { "_wxDataObjectComposite","_class_wxDataObjectComposite",0},
-    { "_class_wxJoystickEvent","_wxJoystickEvent",0},
-    { "_class_wxTipProvider","_wxTipProvider",0},
-    { "_class_wxMiniFrame","_wxMiniFrame",0},
-    { "_wxFontDialog","_class_wxFontDialog",0},
-    { "_wxMemoryFSHandler","_class_wxMemoryFSHandler",0},
-    { "_wxRegion","_class_wxRegion",0},
-    { "_class_wxSplitterWindow","_wxSplitterWindow",0},
-    { "_wxPreviewFrame","_class_wxPreviewFrame",0},
-    { "_wxSizer","_class_wxSizer",0},
-    { "_class_wxDateSpan","_wxDateSpan",0},
-    { "_wxFileSystem","_class_wxFileSystem",0},
-    { "_class_wxShowEvent","_wxShowEvent",0},
-    { "_class_wxPyTipProvider","_wxPyTipProvider",0},
-    { "_class_wxPCXHandler","_wxPCXHandler",0},
-    { "_wxTIFFHandler","_class_wxTIFFHandler",0},
-    { "_wxDiagram","_class_wxDiagram",0},
-    { "_wxPyDropTarget","_class_wxPyDropTarget",0},
-    { "_wxActivateEvent","_class_wxActivateEvent",0},
-    { "_wxGauge","_class_wxGauge",0},
-    { "_class_wxCheckListBox","_wxCheckListBox",0},
-    { "_class_wxBusyInfo","_wxBusyInfo",0},
-    { "_class_wxJoystick","_wxJoystick",0},
-    { "_class_wxCommandEvent","_wxCommandEvent",0},
-    { "_class_wxClientDC","_wxClientDC",0},
-    { "_class_wxSizeEvent","_wxSizeEvent",0},
-    { "_class_wxListCtrl","_wxListCtrl",0},
-    { "_class_wxPyDividedShape","_wxPyDividedShape",0},
-    { "_wxPyEllipseShape","_class_wxPyEllipseShape",0},
-    { "_wxCustomDataObject","_class_wxCustomDataObject",0},
-    { "_class_wxLogNull","_wxLogNull",0},
-    { "_class_wxSize","_wxSize",0},
-    { "_class_wxBitmap","_wxBitmap",0},
-    { "_class_wxMemoryDC","_wxMemoryDC",0},
-    { "_wxPyTextDropTarget","_class_wxPyTextDropTarget",0},
-    { "_wxMenuBar","_class_wxMenuBar",0},
-    { "_wxOutputStream","_class_wxOutputStream",0},
-    { "_wxTreeEvent","_class_wxTreeEvent",0},
-    { "_wxDirDialog","_class_wxDirDialog",0},
-    { "_wxPyShapeEvtHandler","_class_wxPyShapeEvtHandler",0},
-    { "_wxEvtHandler","_class_wxEvtHandler",0},
-    { "_wxMenuItem","_class_wxMenuItem",0},
-    { "_class_wxScrollBar","_wxScrollBar",0},
-    { "_class_wxColourDialog","_wxColourDialog",0},
-    { "_class_wxPrintData","_wxPrintData",0},
-    { "_wxPyRectangleShape","_class_wxPyRectangleShape",0},
-    { "_class_wxScrolledWindow","_wxScrolledWindow",0},
-    { "_wxListItemAttr","_class_wxListItemAttr",0},
-    { "_class_wxTextEntryDialog","_wxTextEntryDialog",0},
-    { "_class_wxConfig","_wxConfig",0},
-    { "_wxKeyEvent","_class_wxKeyEvent",0},
-    { "_wxMoveEvent","_class_wxMoveEvent",0},
-    { "_wxOGLConstraint","_class_wxOGLConstraint",0},
-    { "_wxColourData","_class_wxColourData",0},
-    { "_wxPageSetupDialogData","_class_wxPageSetupDialogData",0},
-    { "_class_wxPalette","_wxPalette",0},
-    { "_wxFileDataObject","_class_wxFileDataObject",0},
-    { "_class_wxQueryLayoutInfoEvent","_wxQueryLayoutInfoEvent",0},
-    { "_wxNotebookSizer","_class_wxNotebookSizer",0},
-    { "_class_wxEraseEvent","_wxEraseEvent",0},
-    { "_wxPyFontEnumerator","_class_wxPyFontEnumerator",0},
-    { "_wxMDIClientWindow","_class_wxMDIClientWindow",0},
-    { "_class_wxPyTextShape","_wxPyTextShape",0},
-    { "_class_wxDataObjectComposite","_wxDataObjectComposite",0},
-    { "_class_wxToolBarToolBase","_wxToolBarToolBase",0},
-    { "_class_wxFontDialog","_wxFontDialog",0},
-    { "_wxWindow","_class_wxWindow",0},
-    { "_class_wxWindowDestroyEvent","_wxWindowDestroyEvent",0},
-    { "_wxLogStderr","_class_wxLogStderr",0},
-    { "_class_wxFileSystemHandler","_wxFileSystemHandler",0},
-    { "_class_wxFileSystem","_wxFileSystem",0},
-    { "_class_wxFrame","_wxFrame",0},
-    { "_class_wxDiagram","_wxDiagram",0},
-{0,0,0}};
-
-static PyObject *SWIG_globals;
-#ifdef __cplusplus
-extern "C" 
-#endif
-SWIGEXPORT(void) initoglc() {
-	 PyObject *m, *d;
-	 SWIG_globals = SWIG_newvarlink();
-	 m = Py_InitModule("oglc", oglcMethods);
-	 d = PyModule_GetDict(m);
-	 PyDict_SetItemString(d,"KEY_SHIFT", PyInt_FromLong((long) KEY_SHIFT));
-	 PyDict_SetItemString(d,"KEY_CTRL", PyInt_FromLong((long) KEY_CTRL));
-	 PyDict_SetItemString(d,"ARROW_NONE", PyInt_FromLong((long) ARROW_NONE));
-	 PyDict_SetItemString(d,"ARROW_END", PyInt_FromLong((long) ARROW_END));
-	 PyDict_SetItemString(d,"ARROW_BOTH", PyInt_FromLong((long) ARROW_BOTH));
-	 PyDict_SetItemString(d,"ARROW_MIDDLE", PyInt_FromLong((long) ARROW_MIDDLE));
-	 PyDict_SetItemString(d,"ARROW_START", PyInt_FromLong((long) ARROW_START));
-	 PyDict_SetItemString(d,"ARROW_HOLLOW_CIRCLE", PyInt_FromLong((long) ARROW_HOLLOW_CIRCLE));
-	 PyDict_SetItemString(d,"ARROW_FILLED_CIRCLE", PyInt_FromLong((long) ARROW_FILLED_CIRCLE));
-	 PyDict_SetItemString(d,"ARROW_ARROW", PyInt_FromLong((long) ARROW_ARROW));
-	 PyDict_SetItemString(d,"ARROW_SINGLE_OBLIQUE", PyInt_FromLong((long) ARROW_SINGLE_OBLIQUE));
-	 PyDict_SetItemString(d,"ARROW_DOUBLE_OBLIQUE", PyInt_FromLong((long) ARROW_DOUBLE_OBLIQUE));
-	 PyDict_SetItemString(d,"ARROW_METAFILE", PyInt_FromLong((long) ARROW_METAFILE));
-	 PyDict_SetItemString(d,"ARROW_POSITION_END", PyInt_FromLong((long) ARROW_POSITION_END));
-	 PyDict_SetItemString(d,"ARROW_POSITION_START", PyInt_FromLong((long) ARROW_POSITION_START));
-	 PyDict_SetItemString(d,"CONTROL_POINT_VERTICAL", PyInt_FromLong((long) CONTROL_POINT_VERTICAL));
-	 PyDict_SetItemString(d,"CONTROL_POINT_HORIZONTAL", PyInt_FromLong((long) CONTROL_POINT_HORIZONTAL));
-	 PyDict_SetItemString(d,"CONTROL_POINT_DIAGONAL", PyInt_FromLong((long) CONTROL_POINT_DIAGONAL));
-	 PyDict_SetItemString(d,"CONTROL_POINT_ENDPOINT_TO", PyInt_FromLong((long) CONTROL_POINT_ENDPOINT_TO));
-	 PyDict_SetItemString(d,"CONTROL_POINT_ENDPOINT_FROM", PyInt_FromLong((long) CONTROL_POINT_ENDPOINT_FROM));
-	 PyDict_SetItemString(d,"CONTROL_POINT_LINE", PyInt_FromLong((long) CONTROL_POINT_LINE));
-	 PyDict_SetItemString(d,"FORMAT_NONE", PyInt_FromLong((long) FORMAT_NONE));
-	 PyDict_SetItemString(d,"FORMAT_CENTRE_HORIZ", PyInt_FromLong((long) FORMAT_CENTRE_HORIZ));
-	 PyDict_SetItemString(d,"FORMAT_CENTRE_VERT", PyInt_FromLong((long) FORMAT_CENTRE_VERT));
-	 PyDict_SetItemString(d,"FORMAT_SIZE_TO_CONTENTS", PyInt_FromLong((long) FORMAT_SIZE_TO_CONTENTS));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_HORIZ", PyInt_FromLong((long) LINE_ALIGNMENT_HORIZ));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_VERT", PyInt_FromLong((long) LINE_ALIGNMENT_VERT));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_TO_NEXT_HANDLE", PyInt_FromLong((long) LINE_ALIGNMENT_TO_NEXT_HANDLE));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_NONE", PyInt_FromLong((long) LINE_ALIGNMENT_NONE));
-	 PyDict_SetItemString(d,"SHADOW_NONE", PyInt_FromLong((long) SHADOW_NONE));
-	 PyDict_SetItemString(d,"SHADOW_LEFT", PyInt_FromLong((long) SHADOW_LEFT));
-	 PyDict_SetItemString(d,"SHADOW_RIGHT", PyInt_FromLong((long) SHADOW_RIGHT));
-	 PyDict_SetItemString(d,"OP_CLICK_LEFT", PyInt_FromLong((long) OP_CLICK_LEFT));
-	 PyDict_SetItemString(d,"OP_CLICK_RIGHT", PyInt_FromLong((long) OP_CLICK_RIGHT));
-	 PyDict_SetItemString(d,"OP_DRAG_LEFT", PyInt_FromLong((long) OP_DRAG_LEFT));
-	 PyDict_SetItemString(d,"OP_DRAG_RIGHT", PyInt_FromLong((long) OP_DRAG_RIGHT));
-	 PyDict_SetItemString(d,"OP_ALL", PyInt_FromLong((long) OP_ALL));
-	 PyDict_SetItemString(d,"ATTACHMENT_MODE_NONE", PyInt_FromLong((long) ATTACHMENT_MODE_NONE));
-	 PyDict_SetItemString(d,"ATTACHMENT_MODE_EDGE", PyInt_FromLong((long) ATTACHMENT_MODE_EDGE));
-	 PyDict_SetItemString(d,"ATTACHMENT_MODE_BRANCHING", PyInt_FromLong((long) ATTACHMENT_MODE_BRANCHING));
-	 PyDict_SetItemString(d,"BRANCHING_ATTACHMENT_NORMAL", PyInt_FromLong((long) BRANCHING_ATTACHMENT_NORMAL));
-	 PyDict_SetItemString(d,"BRANCHING_ATTACHMENT_BLOB", PyInt_FromLong((long) BRANCHING_ATTACHMENT_BLOB));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_CENTRED_VERTICALLY", PyInt_FromLong((long) gyCONSTRAINT_CENTRED_VERTICALLY));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_CENTRED_HORIZONTALLY", PyInt_FromLong((long) gyCONSTRAINT_CENTRED_HORIZONTALLY));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_CENTRED_BOTH", PyInt_FromLong((long) gyCONSTRAINT_CENTRED_BOTH));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_LEFT_OF", PyInt_FromLong((long) gyCONSTRAINT_LEFT_OF));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_RIGHT_OF", PyInt_FromLong((long) gyCONSTRAINT_RIGHT_OF));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ABOVE", PyInt_FromLong((long) gyCONSTRAINT_ABOVE));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_BELOW", PyInt_FromLong((long) gyCONSTRAINT_BELOW));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_TOP", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_TOP));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_BOTTOM", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_BOTTOM));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_LEFT", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_LEFT));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_RIGHT", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_RIGHT));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_TOP", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_TOP));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_BOTTOM", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_BOTTOM));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_LEFT", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_LEFT));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_RIGHT", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_RIGHT));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_NONE", PyInt_FromLong((long) DIVISION_SIDE_NONE));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_LEFT", PyInt_FromLong((long) DIVISION_SIDE_LEFT));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_TOP", PyInt_FromLong((long) DIVISION_SIDE_TOP));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_RIGHT", PyInt_FromLong((long) DIVISION_SIDE_RIGHT));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_BOTTOM", PyInt_FromLong((long) DIVISION_SIDE_BOTTOM));
-
-
-    initoglbasicc();
-    initoglshapesc();
-    initoglshapes2c();
-    initoglcanvasc();
-
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-{
-   int i;
-   for (i = 0; _swig_mapping[i].n1; i++)
-        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
-}
-}

wxPython/contrib/ogl/ogl.i

@@ -1,167 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        ogl.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     30-June-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module ogl
-
-%{
-#include "helpers.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-%import oglbasic.i
-%import oglshapes.i
-%import oglshapes2.i
-%import oglcanvas.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-
-
-enum {
-    KEY_SHIFT,
-    KEY_CTRL,
-    ARROW_NONE,
-    ARROW_END,
-    ARROW_BOTH,
-    ARROW_MIDDLE,
-    ARROW_START,
-    ARROW_HOLLOW_CIRCLE,
-    ARROW_FILLED_CIRCLE,
-    ARROW_ARROW,
-    ARROW_SINGLE_OBLIQUE,
-    ARROW_DOUBLE_OBLIQUE,
-    ARROW_METAFILE,
-    ARROW_POSITION_END,
-    ARROW_POSITION_START,
-    CONTROL_POINT_VERTICAL,
-    CONTROL_POINT_HORIZONTAL,
-    CONTROL_POINT_DIAGONAL,
-    CONTROL_POINT_ENDPOINT_TO,
-    CONTROL_POINT_ENDPOINT_FROM,
-    CONTROL_POINT_LINE,
-    FORMAT_NONE,
-    FORMAT_CENTRE_HORIZ,
-    FORMAT_CENTRE_VERT,
-    FORMAT_SIZE_TO_CONTENTS,
-    LINE_ALIGNMENT_HORIZ,
-    LINE_ALIGNMENT_VERT,
-    LINE_ALIGNMENT_TO_NEXT_HANDLE,
-    LINE_ALIGNMENT_NONE,
-    SHADOW_NONE,
-    SHADOW_LEFT,
-    SHADOW_RIGHT,
-//      SHAPE_BASIC,
-//      SHAPE_RECTANGLE,
-//      SHAPE_ELLIPSE,
-//      SHAPE_POLYGON,
-//      SHAPE_CIRCLE,
-//      SHAPE_LINE,
-//      SHAPE_DIVIDED_RECTANGLE,
-//      SHAPE_COMPOSITE,
-//      SHAPE_CONTROL_POINT,
-//      SHAPE_DRAWN,
-//      SHAPE_DIVISION,
-//      SHAPE_LABEL_OBJECT,
-//      SHAPE_BITMAP,
-//      SHAPE_DIVIDED_OBJECT_CONTROL_POINT,
-//      OBJECT_REGION,
-    OP_CLICK_LEFT,
-    OP_CLICK_RIGHT,
-    OP_DRAG_LEFT,
-    OP_DRAG_RIGHT,
-    OP_ALL,
-    ATTACHMENT_MODE_NONE,
-    ATTACHMENT_MODE_EDGE,
-    ATTACHMENT_MODE_BRANCHING,
-    BRANCHING_ATTACHMENT_NORMAL,
-    BRANCHING_ATTACHMENT_BLOB,
-
-    gyCONSTRAINT_CENTRED_VERTICALLY,
-    gyCONSTRAINT_CENTRED_HORIZONTALLY,
-    gyCONSTRAINT_CENTRED_BOTH,
-    gyCONSTRAINT_LEFT_OF,
-    gyCONSTRAINT_RIGHT_OF,
-    gyCONSTRAINT_ABOVE,
-    gyCONSTRAINT_BELOW,
-    gyCONSTRAINT_ALIGNED_TOP,
-    gyCONSTRAINT_ALIGNED_BOTTOM,
-    gyCONSTRAINT_ALIGNED_LEFT,
-    gyCONSTRAINT_ALIGNED_RIGHT,
-    gyCONSTRAINT_MIDALIGNED_TOP,
-    gyCONSTRAINT_MIDALIGNED_BOTTOM,
-    gyCONSTRAINT_MIDALIGNED_LEFT,
-    gyCONSTRAINT_MIDALIGNED_RIGHT,
-
-    DIVISION_SIDE_NONE,
-    DIVISION_SIDE_LEFT,
-    DIVISION_SIDE_TOP,
-    DIVISION_SIDE_RIGHT,
-    DIVISION_SIDE_BOTTOM,
-
-};
-
-
-
-//---------------------------------------------------------------------------
-
-void wxOGLInitialize();
-void wxOGLCleanUp();
-
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-%{
-extern "C" SWIGEXPORT(void) initoglbasicc();
-extern "C" SWIGEXPORT(void) initoglshapesc();
-extern "C" SWIGEXPORT(void) initoglshapes2c();
-extern "C" SWIGEXPORT(void) initoglcanvasc();
-%}
-
-
-%init %{
-
-    initoglbasicc();
-    initoglshapesc();
-    initoglshapes2c();
-    initoglcanvasc();
-
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-%}
-
-//----------------------------------------------------------------------
-// And this gets appended to the shadow class file.
-//----------------------------------------------------------------------
-
-%pragma(python) include="_oglextras.py";
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------

wxPython/contrib/ogl/ogl.py

@@ -1,165 +0,0 @@
-# This file was created automatically by SWIG.
-import oglc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-
-from oglbasic import *
-
-from oglshapes import *
-
-from oglshapes2 import *
-
-from oglcanvas import *
-import wx
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-wxOGLInitialize = oglc.wxOGLInitialize
-
-wxOGLCleanUp = oglc.wxOGLCleanUp
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-KEY_SHIFT = oglc.KEY_SHIFT
-KEY_CTRL = oglc.KEY_CTRL
-ARROW_NONE = oglc.ARROW_NONE
-ARROW_END = oglc.ARROW_END
-ARROW_BOTH = oglc.ARROW_BOTH
-ARROW_MIDDLE = oglc.ARROW_MIDDLE
-ARROW_START = oglc.ARROW_START
-ARROW_HOLLOW_CIRCLE = oglc.ARROW_HOLLOW_CIRCLE
-ARROW_FILLED_CIRCLE = oglc.ARROW_FILLED_CIRCLE
-ARROW_ARROW = oglc.ARROW_ARROW
-ARROW_SINGLE_OBLIQUE = oglc.ARROW_SINGLE_OBLIQUE
-ARROW_DOUBLE_OBLIQUE = oglc.ARROW_DOUBLE_OBLIQUE
-ARROW_METAFILE = oglc.ARROW_METAFILE
-ARROW_POSITION_END = oglc.ARROW_POSITION_END
-ARROW_POSITION_START = oglc.ARROW_POSITION_START
-CONTROL_POINT_VERTICAL = oglc.CONTROL_POINT_VERTICAL
-CONTROL_POINT_HORIZONTAL = oglc.CONTROL_POINT_HORIZONTAL
-CONTROL_POINT_DIAGONAL = oglc.CONTROL_POINT_DIAGONAL
-CONTROL_POINT_ENDPOINT_TO = oglc.CONTROL_POINT_ENDPOINT_TO
-CONTROL_POINT_ENDPOINT_FROM = oglc.CONTROL_POINT_ENDPOINT_FROM
-CONTROL_POINT_LINE = oglc.CONTROL_POINT_LINE
-FORMAT_NONE = oglc.FORMAT_NONE
-FORMAT_CENTRE_HORIZ = oglc.FORMAT_CENTRE_HORIZ
-FORMAT_CENTRE_VERT = oglc.FORMAT_CENTRE_VERT
-FORMAT_SIZE_TO_CONTENTS = oglc.FORMAT_SIZE_TO_CONTENTS
-LINE_ALIGNMENT_HORIZ = oglc.LINE_ALIGNMENT_HORIZ
-LINE_ALIGNMENT_VERT = oglc.LINE_ALIGNMENT_VERT
-LINE_ALIGNMENT_TO_NEXT_HANDLE = oglc.LINE_ALIGNMENT_TO_NEXT_HANDLE
-LINE_ALIGNMENT_NONE = oglc.LINE_ALIGNMENT_NONE
-SHADOW_NONE = oglc.SHADOW_NONE
-SHADOW_LEFT = oglc.SHADOW_LEFT
-SHADOW_RIGHT = oglc.SHADOW_RIGHT
-OP_CLICK_LEFT = oglc.OP_CLICK_LEFT
-OP_CLICK_RIGHT = oglc.OP_CLICK_RIGHT
-OP_DRAG_LEFT = oglc.OP_DRAG_LEFT
-OP_DRAG_RIGHT = oglc.OP_DRAG_RIGHT
-OP_ALL = oglc.OP_ALL
-ATTACHMENT_MODE_NONE = oglc.ATTACHMENT_MODE_NONE
-ATTACHMENT_MODE_EDGE = oglc.ATTACHMENT_MODE_EDGE
-ATTACHMENT_MODE_BRANCHING = oglc.ATTACHMENT_MODE_BRANCHING
-BRANCHING_ATTACHMENT_NORMAL = oglc.BRANCHING_ATTACHMENT_NORMAL
-BRANCHING_ATTACHMENT_BLOB = oglc.BRANCHING_ATTACHMENT_BLOB
-gyCONSTRAINT_CENTRED_VERTICALLY = oglc.gyCONSTRAINT_CENTRED_VERTICALLY
-gyCONSTRAINT_CENTRED_HORIZONTALLY = oglc.gyCONSTRAINT_CENTRED_HORIZONTALLY
-gyCONSTRAINT_CENTRED_BOTH = oglc.gyCONSTRAINT_CENTRED_BOTH
-gyCONSTRAINT_LEFT_OF = oglc.gyCONSTRAINT_LEFT_OF
-gyCONSTRAINT_RIGHT_OF = oglc.gyCONSTRAINT_RIGHT_OF
-gyCONSTRAINT_ABOVE = oglc.gyCONSTRAINT_ABOVE
-gyCONSTRAINT_BELOW = oglc.gyCONSTRAINT_BELOW
-gyCONSTRAINT_ALIGNED_TOP = oglc.gyCONSTRAINT_ALIGNED_TOP
-gyCONSTRAINT_ALIGNED_BOTTOM = oglc.gyCONSTRAINT_ALIGNED_BOTTOM
-gyCONSTRAINT_ALIGNED_LEFT = oglc.gyCONSTRAINT_ALIGNED_LEFT
-gyCONSTRAINT_ALIGNED_RIGHT = oglc.gyCONSTRAINT_ALIGNED_RIGHT
-gyCONSTRAINT_MIDALIGNED_TOP = oglc.gyCONSTRAINT_MIDALIGNED_TOP
-gyCONSTRAINT_MIDALIGNED_BOTTOM = oglc.gyCONSTRAINT_MIDALIGNED_BOTTOM
-gyCONSTRAINT_MIDALIGNED_LEFT = oglc.gyCONSTRAINT_MIDALIGNED_LEFT
-gyCONSTRAINT_MIDALIGNED_RIGHT = oglc.gyCONSTRAINT_MIDALIGNED_RIGHT
-DIVISION_SIDE_NONE = oglc.DIVISION_SIDE_NONE
-DIVISION_SIDE_LEFT = oglc.DIVISION_SIDE_LEFT
-DIVISION_SIDE_TOP = oglc.DIVISION_SIDE_TOP
-DIVISION_SIDE_RIGHT = oglc.DIVISION_SIDE_RIGHT
-DIVISION_SIDE_BOTTOM = oglc.DIVISION_SIDE_BOTTOM
-
-
-#-------------- USER INCLUDE -----------------------
-
-
-wxShapeCanvas =       wxPyShapeCanvas
-wxShapeEvtHandler =   wxPyShapeEvtHandler
-wxShape =             wxPyShape
-wxRectangleShape =    wxPyRectangleShape
-wxBitmapShape =       wxPyBitmapShape
-wxDrawnShape =        wxPyDrawnShape
-wxCompositeShape =    wxPyCompositeShape
-wxDividedShape =      wxPyDividedShape
-wxDivisionShape =     wxPyDivisionShape
-wxEllipseShape =      wxPyEllipseShape
-wxCircleShape =       wxPyCircleShape
-wxLineShape =         wxPyLineShape
-wxPolygonShape =      wxPyPolygonShape
-wxTextShape =         wxPyTextShape
-wxControlPoint =      wxPyControlPoint
-
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-import wx
-wx.wxPyShapeCanvasPtr     = wxPyShapeCanvasPtr
-wx.wxPyShapeEvtHandlerPtr = wxPyShapeEvtHandlerPtr
-wx.wxPyShapePtr           = wxPyShapePtr
-wx.wxPyRectangleShapePtr  = wxPyRectangleShapePtr
-wx.wxPyBitmapShapePtr     = wxPyBitmapShapePtr
-wx.wxPyDrawnShapePtr      = wxPyDrawnShapePtr
-wx.wxPyCompositeShapePtr  = wxPyCompositeShapePtr
-wx.wxPyDividedShapePtr    = wxPyDividedShapePtr
-wx.wxPyDivisionShapePtr   = wxPyDivisionShapePtr
-wx.wxPyEllipseShapePtr    = wxPyEllipseShapePtr
-wx.wxPyCircleShapePtr     = wxPyCircleShapePtr
-wx.wxPyLineShapePtr       = wxPyLineShapePtr
-wx.wxPyPolygonShapePtr    = wxPyPolygonShapePtr
-wx.wxPyTextShapePtr       = wxPyTextShapePtr
-wx.wxShapeRegionPtr       = wxShapeRegionPtr
-wx.wxOGLConstraintPtr     = wxOGLConstraintPtr
-wx.wxControlPointPtr      = wxPyControlPointPtr

wxPython/contrib/ogl/oglbasic.i

@@ -1,401 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglbasic.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     3-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module oglbasic
-
-%{
-#include "helpers.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-//%extern oglcanvas.i
-
-
-%pragma(python) code = "import wx"
-%pragma(python) code = "from oglcanvas import wxPyShapeCanvasPtr"
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-
-class wxShapeRegion {
-public:
-    wxShapeRegion();
-    //~wxShapeRegion();
-
-    void SetText(const wxString& s);
-    void SetFont(wxFont *f);
-    void SetMinSize(double w, double h);
-    void SetSize(double w, double h);
-    void SetPosition(double x, double y);
-    void SetProportions(double x, double y);
-    void SetFormatMode(int mode);
-    void SetName(const wxString& s);
-    void SetColour(const wxString& col);
-
-    wxString GetText();
-    wxFont *GetFont();
-    void GetMinSize(double *OUTPUT, double *OUTPUT);
-    void GetProportion(double *OUTPUT, double *OUTPUT);
-    void GetSize(double *OUTPUT, double *OUTPUT);
-    void GetPosition(double *OUTPUT, double *OUTPUT);
-    int GetFormatMode();
-    wxString GetName();
-    wxString GetColour();
-    wxColour *GetActualColourObject();
-    wxList& GetFormattedText();
-    wxString GetPenColour();
-    int GetPenStyle();
-    void SetPenStyle(int style);
-    void SetPenColour(const wxString& col);
-    wxPen *GetActualPen();
-    double GetWidth();
-    double GetHeight();
-
-    void ClearText();
-};
-
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyShapeEvtHandler,wxShapeEvtHandler);
-%}
-
-
-class wxPyShapeEvtHandler {
-public:
-    wxPyShapeEvtHandler(wxPyShapeEvtHandler *prev = NULL,
-                        wxPyShape *shape = NULL);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyShapeEvtHandler)"
-
-    %addmethods {
-        void Destroy() { delete self; }
-    }
-
-    void SetShape(wxPyShape *sh);
-    wxPyShape *GetShape();
-    void SetPreviousHandler(wxPyShapeEvtHandler* handler);
-    wxPyShapeEvtHandler* GetPreviousHandler();
-    wxPyShapeEvtHandler* CreateNewCopy();
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyShape, wxShape);
-%}
-
-
-class wxPyShape : public wxPyShapeEvtHandler {
-public:
-    // wxPyShape(wxPyShapeCanvas *can = NULL);     abstract base class...
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyShape)"
-
-    %addmethods {
-        void Destroy() { delete self; }
-    }
-
-    void GetBoundingBoxMax(double *OUTPUT, double *OUTPUT);
-    void GetBoundingBoxMin(double *OUTPUT, double *OUTPUT);
-    bool GetPerimeterPoint(double x1, double y1,
-                           double x2, double y2,
-                           double *OUTPUT, double *OUTPUT);
-    wxPyShapeCanvas *GetCanvas();
-    void SetCanvas(wxPyShapeCanvas *the_canvas);
-    void AddToCanvas(wxPyShapeCanvas *the_canvas, wxPyShape *addAfter = NULL);
-    void InsertInCanvas(wxPyShapeCanvas *the_canvas);
-    void RemoveFromCanvas(wxPyShapeCanvas *the_canvas);
-    double GetX();
-    double GetY();
-    void SetX(double x);
-    void SetY(double y);
-    wxPyShape *GetParent();
-    void SetParent(wxPyShape *p);
-    wxPyShape *GetTopAncestor();
-
-
-    // wxList& GetChildren();
-    %addmethods {
-        PyObject* GetChildren() {
-            wxList& list = self->GetChildren();
-            return wxPy_ConvertList(&list, "wxPyShape");
-        }
-    }
-
-
-    void Unlink();
-    void SetDrawHandles(bool drawH);
-    bool GetDrawHandles();
-    void MakeControlPoints();
-    void DeleteControlPoints(wxDC *dc = NULL);
-    void ResetControlPoints();
-    wxPyShapeEvtHandler *GetEventHandler();
-    void SetEventHandler(wxPyShapeEvtHandler *handler);
-    void MakeMandatoryControlPoints();
-    void ResetMandatoryControlPoints();
-    bool Recompute();
-    void CalculateSize();
-    void Select(bool select = TRUE, wxDC* dc = NULL);
-    void SetHighlight(bool hi = TRUE, bool recurse = FALSE);
-    bool IsHighlighted() ;
-    bool Selected();
-    bool AncestorSelected();
-    void SetSensitivityFilter(int sens = OP_ALL, bool recursive = FALSE);
-    int GetSensitivityFilter();
-    void SetDraggable(bool drag, bool recursive = FALSE);
-    void SetFixedSize(bool x, bool y);
-    void GetFixedSize(bool *OUTPUT, bool *OUTPUT) ;
-    bool GetFixedWidth();
-    bool GetFixedHeight();
-    void SetSpaceAttachments(bool sp);
-    bool GetSpaceAttachments() ;
-    void SetShadowMode(int mode, bool redraw = FALSE);
-    int GetShadowMode();
-    bool HitTest(double x, double y, int *OUTPUT, double *OUTPUT);
-    void SetCentreResize(bool cr);
-    bool GetCentreResize();
-    void SetMaintainAspectRatio(bool ar);
-    bool GetMaintainAspectRatio();
-
-
-    // wxList& GetLines();
-    %addmethods {
-        PyObject* GetLines() {
-            wxList& list = self->GetLines();
-            return wxPy_ConvertList(&list, "wxPyLineShape");
-        }
-    }
-
-    void SetDisableLabel(bool flag);
-    bool GetDisableLabel();
-    void SetAttachmentMode(int mode);
-    int GetAttachmentMode();
-    void SetId(long i);
-    long GetId();
-    void SetPen(wxPen *pen);
-    void SetBrush(wxBrush *brush);
-
-    // void SetClientData(wxObject *client_data);
-    // wxObject *GetClientData();
-    %addmethods {
-        void SetClientData(PyObject* userData) {
-            wxPyUserData* data = NULL;
-            if (userData)
-                data = new wxPyUserData(userData);
-            self->SetClientData(data);
-        }
-
-        PyObject* GetClientData() {
-            wxPyUserData* data = (wxPyUserData*)self->GetClientData();
-            if (data) {
-                Py_INCREF(data->m_obj);
-                return data->m_obj;
-            } else {
-                Py_INCREF(Py_None);
-                return Py_None;
-            }
-        }
-    }
-
-    void Show(bool show);
-    bool IsShown();
-    void Move(wxDC& dc, double x1, double y1, bool display = TRUE);
-    void Erase(wxDC& dc);
-    void EraseContents(wxDC& dc);
-    void Draw(wxDC& dc);
-    void Flash();
-    void MoveLinks(wxDC& dc);
-    void DrawContents(wxDC& dc);
-    void SetSize(double x, double y, bool recursive = TRUE);
-    void SetAttachmentSize(double x, double y);
-    void Attach(wxPyShapeCanvas *can);
-    void Detach();
-    bool Constrain();
-    void AddLine(wxPyLineShape *line, wxPyShape *other,
-                 int attachFrom = 0, int attachTo = 0,
-                 int positionFrom = -1, int positionTo = -1);
-    int GetLinePosition(wxPyLineShape* line);
-    void AddText(const wxString& string);
-    wxPen *GetPen();
-    wxBrush *GetBrush();
-    void SetDefaultRegionSize();
-    void FormatText(wxDC& dc, const wxString& s, int regionId = 0);
-    void SetFormatMode(int mode, int regionId = 0);
-    int GetFormatMode(int regionId = 0);
-    void SetFont(wxFont *font, int regionId = 0);
-    wxFont *GetFont(int regionId = 0);
-    void SetTextColour(const wxString& colour, int regionId = 0);
-    wxString GetTextColour(int regionId = 0);
-    int GetNumberOfTextRegions();
-    void SetRegionName(const wxString& name, int regionId = 0);
-    wxString GetRegionName(int regionId);
-    int GetRegionId(const wxString& name);
-    void NameRegions(const wxString& parentName = "");
-
-    // wxList& GetRegions();
-    %addmethods {
-        PyObject* GetRegions() {
-            wxList& list = self->GetRegions();
-            return wxPy_ConvertList(&list, "wxShapeRegion");
-        }
-    }
-
-    void AddRegion(wxShapeRegion *region);
-    void ClearRegions();
-    void AssignNewIds();
-    wxPyShape *FindRegion(const wxString& regionName, int *OUTPUT);
-    void FindRegionNames(wxStringList& list);
-    void ClearText(int regionId = 0);
-    void RemoveLine(wxPyLineShape *line);
-
-#ifdef PROLOGIO
-    void WriteAttributes(wxExpr *clause);
-    void ReadAttributes(wxExpr *clause);
-    void ReadConstraints(wxExpr *clause, wxExprDatabase *database);
-    void WriteRegions(wxExpr *clause);
-    void ReadRegions(wxExpr *clause);
-#endif
-
-    bool GetAttachmentPosition(int attachment, double *OUTPUT, double *OUTPUT,
-                               int nth = 0, int no_arcs = 1, wxPyLineShape *line = NULL);
-    int GetNumberOfAttachments();
-    bool AttachmentIsValid(int attachment);
-    bool GetAttachmentPositionEdge(int attachment, double *OUTPUT, double *OUTPUT,
-                                   int nth = 0, int no_arcs = 1, wxPyLineShape *line = NULL);
-    wxRealPoint CalcSimpleAttachment(const wxRealPoint& pt1, const wxRealPoint& pt2,
-                                     int nth, int noArcs, wxPyLineShape* line);
-    bool AttachmentSortTest(int attachmentPoint, const wxRealPoint& pt1, const wxRealPoint& pt2);
-    void EraseLinks(wxDC& dc, int attachment = -1, bool recurse = FALSE);
-    void DrawLinks(wxDC& dc, int attachment = -1, bool recurse = FALSE);
-    bool MoveLineToNewAttachment(wxDC& dc, wxPyLineShape *to_move,
-                                 double x, double y);
-
-    //void ApplyAttachmentOrdering(wxList& linesToSort);
-    %addmethods {
-        void ApplyAttachmentOrdering(PyObject* linesToSort) {
-            wxList* list = wxPy_wxListHelper(linesToSort, "_wxPyLineShape_p");
-            self->ApplyAttachmentOrdering(*list);
-            delete list;
-        }
-    }
-
-    wxRealPoint GetBranchingAttachmentRoot(int attachment);
-    bool GetBranchingAttachmentInfo(int attachment, wxRealPoint& root, wxRealPoint& neck,
-                                    wxRealPoint& shoulder1, wxRealPoint& shoulder2);
-    bool GetBranchingAttachmentPoint(int attachment, int n, wxRealPoint& attachmentPoint,
-                                     wxRealPoint& stemPoint);
-    int GetAttachmentLineCount(int attachment);
-    void SetBranchNeckLength(int len);
-    int GetBranchNeckLength();
-    void SetBranchStemLength(int len);
-    int GetBranchStemLength();
-    void SetBranchSpacing(int len);
-    int GetBranchSpacing();
-    void SetBranchStyle(long style);
-    long GetBranchStyle();
-    int PhysicalToLogicalAttachment(int physicalAttachment);
-    int LogicalToPhysicalAttachment(int logicalAttachment);
-    bool Draggable();
-    bool HasDescendant(wxPyShape *image);
-    wxPyShape *CreateNewCopy(bool resetMapping = TRUE, bool recompute = TRUE);
-    void Copy(wxPyShape& copy);
-    void CopyWithHandler(wxPyShape& copy);
-    void Rotate(double x, double y, double theta);
-    double GetRotation();
-    void ClearAttachments();
-    void Recentre(wxDC& dc);
-    void ClearPointList(wxList& list);
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-

wxPython/contrib/ogl/oglbasic.py

@@ -1,797 +0,0 @@
-# This file was created automatically by SWIG.
-import oglbasicc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-import wx
-from oglcanvas import wxPyShapeCanvasPtr
-class wxShapeRegionPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetText,(self,) + _args, _kwargs)
-        return val
-    def SetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetFont,(self,) + _args, _kwargs)
-        return val
-    def SetMinSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetMinSize,(self,) + _args, _kwargs)
-        return val
-    def SetSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetSize,(self,) + _args, _kwargs)
-        return val
-    def SetPosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetPosition,(self,) + _args, _kwargs)
-        return val
-    def SetProportions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetProportions,(self,) + _args, _kwargs)
-        return val
-    def SetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def SetName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetName,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetColour,(self,) + _args, _kwargs)
-        return val
-    def GetText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetText,(self,) + _args, _kwargs)
-        return val
-    def GetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetFont,(self,) + _args, _kwargs)
-        if val: val = wxFontPtr(val) 
-        return val
-    def GetMinSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetMinSize,(self,) + _args, _kwargs)
-        return val
-    def GetProportion(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetProportion,(self,) + _args, _kwargs)
-        return val
-    def GetSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetSize,(self,) + _args, _kwargs)
-        return val
-    def GetPosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetPosition,(self,) + _args, _kwargs)
-        return val
-    def GetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def GetName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetName,(self,) + _args, _kwargs)
-        return val
-    def GetColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetColour,(self,) + _args, _kwargs)
-        return val
-    def GetActualColourObject(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetActualColourObject,(self,) + _args, _kwargs)
-        if val: val = wxColourPtr(val) 
-        return val
-    def GetFormattedText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetFormattedText,(self,) + _args, _kwargs)
-        return val
-    def GetPenColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetPenColour,(self,) + _args, _kwargs)
-        return val
-    def GetPenStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetPenStyle,(self,) + _args, _kwargs)
-        return val
-    def SetPenStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetPenStyle,(self,) + _args, _kwargs)
-        return val
-    def SetPenColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetPenColour,(self,) + _args, _kwargs)
-        return val
-    def GetActualPen(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetActualPen,(self,) + _args, _kwargs)
-        if val: val = wxPenPtr(val) 
-        return val
-    def GetWidth(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetWidth,(self,) + _args, _kwargs)
-        return val
-    def GetHeight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetHeight,(self,) + _args, _kwargs)
-        return val
-    def ClearText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_ClearText,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxShapeRegion instance at %s>" % (self.this,)
-class wxShapeRegion(wxShapeRegionPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglbasicc.new_wxShapeRegion,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxPyShapeEvtHandlerPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler__setSelf,(self,) + _args, _kwargs)
-        return val
-    def Destroy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_Destroy,(self,) + _args, _kwargs)
-        return val
-    def SetShape(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_SetShape,(self,) + _args, _kwargs)
-        return val
-    def GetShape(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_GetShape,(self,) + _args, _kwargs)
-        if val: val = wxPyShapePtr(val) 
-        return val
-    def SetPreviousHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_SetPreviousHandler,(self,) + _args, _kwargs)
-        return val
-    def GetPreviousHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_GetPreviousHandler,(self,) + _args, _kwargs)
-        if val: val = wxPyShapeEvtHandlerPtr(val) 
-        return val
-    def CreateNewCopy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_CreateNewCopy,(self,) + _args, _kwargs)
-        if val: val = wxPyShapeEvtHandlerPtr(val) 
-        return val
-    def base_OnDelete(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDelete,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyShapeEvtHandler instance at %s>" % (self.this,)
-class wxPyShapeEvtHandler(wxPyShapeEvtHandlerPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglbasicc.new_wxPyShapeEvtHandler,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyShapeEvtHandler)
-
-
-
-
-class wxPyShapePtr(wxPyShapeEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def Destroy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Destroy,(self,) + _args, _kwargs)
-        return val
-    def GetBoundingBoxMax(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBoundingBoxMax,(self,) + _args, _kwargs)
-        return val
-    def GetBoundingBoxMin(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBoundingBoxMin,(self,) + _args, _kwargs)
-        return val
-    def GetPerimeterPoint(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetPerimeterPoint,(self,) + _args, _kwargs)
-        return val
-    def GetCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetCanvas,(self,) + _args, _kwargs)
-        if val: val = wxPyShapeCanvasPtr(val) 
-        return val
-    def SetCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetCanvas,(self,) + _args, _kwargs)
-        return val
-    def AddToCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddToCanvas,(self,) + _args, _kwargs)
-        return val
-    def InsertInCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_InsertInCanvas,(self,) + _args, _kwargs)
-        return val
-    def RemoveFromCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_RemoveFromCanvas,(self,) + _args, _kwargs)
-        return val
-    def GetX(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetX,(self,) + _args, _kwargs)
-        return val
-    def GetY(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetY,(self,) + _args, _kwargs)
-        return val
-    def SetX(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetX,(self,) + _args, _kwargs)
-        return val
-    def SetY(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetY,(self,) + _args, _kwargs)
-        return val
-    def GetParent(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetParent,(self,) + _args, _kwargs)
-        if val: val = wxPyShapePtr(val) 
-        return val
-    def SetParent(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetParent,(self,) + _args, _kwargs)
-        return val
-    def GetTopAncestor(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetTopAncestor,(self,) + _args, _kwargs)
-        if val: val = wxPyShapePtr(val) 
-        return val
-    def GetChildren(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetChildren,(self,) + _args, _kwargs)
-        return val
-    def Unlink(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Unlink,(self,) + _args, _kwargs)
-        return val
-    def SetDrawHandles(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDrawHandles,(self,) + _args, _kwargs)
-        return val
-    def GetDrawHandles(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetDrawHandles,(self,) + _args, _kwargs)
-        return val
-    def MakeControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MakeControlPoints,(self,) + _args, _kwargs)
-        return val
-    def DeleteControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_DeleteControlPoints,(self,) + _args, _kwargs)
-        return val
-    def ResetControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ResetControlPoints,(self,) + _args, _kwargs)
-        return val
-    def GetEventHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetEventHandler,(self,) + _args, _kwargs)
-        if val: val = wxPyShapeEvtHandlerPtr(val) 
-        return val
-    def SetEventHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetEventHandler,(self,) + _args, _kwargs)
-        return val
-    def MakeMandatoryControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MakeMandatoryControlPoints,(self,) + _args, _kwargs)
-        return val
-    def ResetMandatoryControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ResetMandatoryControlPoints,(self,) + _args, _kwargs)
-        return val
-    def Recompute(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Recompute,(self,) + _args, _kwargs)
-        return val
-    def CalculateSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CalculateSize,(self,) + _args, _kwargs)
-        return val
-    def Select(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Select,(self,) + _args, _kwargs)
-        return val
-    def SetHighlight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetHighlight,(self,) + _args, _kwargs)
-        return val
-    def IsHighlighted(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_IsHighlighted,(self,) + _args, _kwargs)
-        return val
-    def Selected(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Selected,(self,) + _args, _kwargs)
-        return val
-    def AncestorSelected(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AncestorSelected,(self,) + _args, _kwargs)
-        return val
-    def SetSensitivityFilter(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetSensitivityFilter,(self,) + _args, _kwargs)
-        return val
-    def GetSensitivityFilter(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetSensitivityFilter,(self,) + _args, _kwargs)
-        return val
-    def SetDraggable(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDraggable,(self,) + _args, _kwargs)
-        return val
-    def SetFixedSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetFixedSize,(self,) + _args, _kwargs)
-        return val
-    def GetFixedSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFixedSize,(self,) + _args, _kwargs)
-        return val
-    def GetFixedWidth(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFixedWidth,(self,) + _args, _kwargs)
-        return val
-    def GetFixedHeight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFixedHeight,(self,) + _args, _kwargs)
-        return val
-    def SetSpaceAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetSpaceAttachments,(self,) + _args, _kwargs)
-        return val
-    def GetSpaceAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetSpaceAttachments,(self,) + _args, _kwargs)
-        return val
-    def SetShadowMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetShadowMode,(self,) + _args, _kwargs)
-        return val
-    def GetShadowMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetShadowMode,(self,) + _args, _kwargs)
-        return val
-    def HitTest(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_HitTest,(self,) + _args, _kwargs)
-        return val
-    def SetCentreResize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetCentreResize,(self,) + _args, _kwargs)
-        return val
-    def GetCentreResize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetCentreResize,(self,) + _args, _kwargs)
-        return val
-    def SetMaintainAspectRatio(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetMaintainAspectRatio,(self,) + _args, _kwargs)
-        return val
-    def GetMaintainAspectRatio(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetMaintainAspectRatio,(self,) + _args, _kwargs)
-        return val
-    def GetLines(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetLines,(self,) + _args, _kwargs)
-        return val
-    def SetDisableLabel(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDisableLabel,(self,) + _args, _kwargs)
-        return val
-    def GetDisableLabel(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetDisableLabel,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetAttachmentMode,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentMode,(self,) + _args, _kwargs)
-        return val
-    def SetId(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetId,(self,) + _args, _kwargs)
-        return val
-    def GetId(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetId,(self,) + _args, _kwargs)
-        return val
-    def SetPen(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetPen,(self,) + _args, _kwargs)
-        return val
-    def SetBrush(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBrush,(self,) + _args, _kwargs)
-        return val
-    def SetClientData(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetClientData,(self,) + _args, _kwargs)
-        return val
-    def GetClientData(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetClientData,(self,) + _args, _kwargs)
-        return val
-    def Show(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Show,(self,) + _args, _kwargs)
-        return val
-    def IsShown(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_IsShown,(self,) + _args, _kwargs)
-        return val
-    def Move(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Move,(self,) + _args, _kwargs)
-        return val
-    def Erase(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Erase,(self,) + _args, _kwargs)
-        return val
-    def EraseContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_EraseContents,(self,) + _args, _kwargs)
-        return val
-    def Draw(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Draw,(self,) + _args, _kwargs)
-        return val
-    def Flash(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Flash,(self,) + _args, _kwargs)
-        return val
-    def MoveLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MoveLinks,(self,) + _args, _kwargs)
-        return val
-    def DrawContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_DrawContents,(self,) + _args, _kwargs)
-        return val
-    def SetSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetSize,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetAttachmentSize,(self,) + _args, _kwargs)
-        return val
-    def Attach(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Attach,(self,) + _args, _kwargs)
-        return val
-    def Detach(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Detach,(self,) + _args, _kwargs)
-        return val
-    def Constrain(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Constrain,(self,) + _args, _kwargs)
-        return val
-    def AddLine(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddLine,(self,) + _args, _kwargs)
-        return val
-    def GetLinePosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetLinePosition,(self,) + _args, _kwargs)
-        return val
-    def AddText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddText,(self,) + _args, _kwargs)
-        return val
-    def GetPen(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetPen,(self,) + _args, _kwargs)
-        if val: val = wxPenPtr(val) 
-        return val
-    def GetBrush(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBrush,(self,) + _args, _kwargs)
-        if val: val = wxBrushPtr(val) 
-        return val
-    def SetDefaultRegionSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDefaultRegionSize,(self,) + _args, _kwargs)
-        return val
-    def FormatText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_FormatText,(self,) + _args, _kwargs)
-        return val
-    def SetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def GetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def SetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetFont,(self,) + _args, _kwargs)
-        return val
-    def GetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFont,(self,) + _args, _kwargs)
-        if val: val = wxFontPtr(val) 
-        return val
-    def SetTextColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetTextColour,(self,) + _args, _kwargs)
-        return val
-    def GetTextColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetTextColour,(self,) + _args, _kwargs)
-        return val
-    def GetNumberOfTextRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetNumberOfTextRegions,(self,) + _args, _kwargs)
-        return val
-    def SetRegionName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetRegionName,(self,) + _args, _kwargs)
-        return val
-    def GetRegionName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRegionName,(self,) + _args, _kwargs)
-        return val
-    def GetRegionId(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRegionId,(self,) + _args, _kwargs)
-        return val
-    def NameRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_NameRegions,(self,) + _args, _kwargs)
-        return val
-    def GetRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRegions,(self,) + _args, _kwargs)
-        return val
-    def AddRegion(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddRegion,(self,) + _args, _kwargs)
-        return val
-    def ClearRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearRegions,(self,) + _args, _kwargs)
-        return val
-    def AssignNewIds(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AssignNewIds,(self,) + _args, _kwargs)
-        return val
-    def FindRegion(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_FindRegion,(self,) + _args, _kwargs)
-        return val
-    def FindRegionNames(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_FindRegionNames,(self,) + _args, _kwargs)
-        return val
-    def ClearText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearText,(self,) + _args, _kwargs)
-        return val
-    def RemoveLine(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_RemoveLine,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentPosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentPosition,(self,) + _args, _kwargs)
-        return val
-    def GetNumberOfAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetNumberOfAttachments,(self,) + _args, _kwargs)
-        return val
-    def AttachmentIsValid(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AttachmentIsValid,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentPositionEdge(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentPositionEdge,(self,) + _args, _kwargs)
-        return val
-    def CalcSimpleAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CalcSimpleAttachment,(self,) + _args, _kwargs)
-        if val: val = wxRealPointPtr(val) ; val.thisown = 1
-        return val
-    def AttachmentSortTest(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AttachmentSortTest,(self,) + _args, _kwargs)
-        return val
-    def EraseLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_EraseLinks,(self,) + _args, _kwargs)
-        return val
-    def DrawLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_DrawLinks,(self,) + _args, _kwargs)
-        return val
-    def MoveLineToNewAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MoveLineToNewAttachment,(self,) + _args, _kwargs)
-        return val
-    def ApplyAttachmentOrdering(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ApplyAttachmentOrdering,(self,) + _args, _kwargs)
-        return val
-    def GetBranchingAttachmentRoot(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchingAttachmentRoot,(self,) + _args, _kwargs)
-        if val: val = wxRealPointPtr(val) ; val.thisown = 1
-        return val
-    def GetBranchingAttachmentInfo(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchingAttachmentInfo,(self,) + _args, _kwargs)
-        return val
-    def GetBranchingAttachmentPoint(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchingAttachmentPoint,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentLineCount(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentLineCount,(self,) + _args, _kwargs)
-        return val
-    def SetBranchNeckLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchNeckLength,(self,) + _args, _kwargs)
-        return val
-    def GetBranchNeckLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchNeckLength,(self,) + _args, _kwargs)
-        return val
-    def SetBranchStemLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchStemLength,(self,) + _args, _kwargs)
-        return val
-    def GetBranchStemLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchStemLength,(self,) + _args, _kwargs)
-        return val
-    def SetBranchSpacing(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchSpacing,(self,) + _args, _kwargs)
-        return val
-    def GetBranchSpacing(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchSpacing,(self,) + _args, _kwargs)
-        return val
-    def SetBranchStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchStyle,(self,) + _args, _kwargs)
-        return val
-    def GetBranchStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchStyle,(self,) + _args, _kwargs)
-        return val
-    def PhysicalToLogicalAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_PhysicalToLogicalAttachment,(self,) + _args, _kwargs)
-        return val
-    def LogicalToPhysicalAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_LogicalToPhysicalAttachment,(self,) + _args, _kwargs)
-        return val
-    def Draggable(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Draggable,(self,) + _args, _kwargs)
-        return val
-    def HasDescendant(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_HasDescendant,(self,) + _args, _kwargs)
-        return val
-    def CreateNewCopy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CreateNewCopy,(self,) + _args, _kwargs)
-        if val: val = wxPyShapePtr(val) 
-        return val
-    def Copy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Copy,(self,) + _args, _kwargs)
-        return val
-    def CopyWithHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CopyWithHandler,(self,) + _args, _kwargs)
-        return val
-    def Rotate(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Rotate,(self,) + _args, _kwargs)
-        return val
-    def GetRotation(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRotation,(self,) + _args, _kwargs)
-        return val
-    def ClearAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearAttachments,(self,) + _args, _kwargs)
-        return val
-    def Recentre(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Recentre,(self,) + _args, _kwargs)
-        return val
-    def ClearPointList(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearPointList,(self,) + _args, _kwargs)
-        return val
-    def base_OnDelete(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDelete,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyShape instance at %s>" % (self.this,)
-class wxPyShape(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/ogl/oglcanvas.i

@@ -1,157 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglcanvas.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     7-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module oglcanvas
-
-%{
-#include "helpers.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-%extern oglbasic.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-class wxDiagram {
-public:
-    wxDiagram();
-    ~wxDiagram();
-
-    void AddShape(wxPyShape*shape, wxPyShape *addAfter = NULL);
-    void Clear(wxDC& dc);
-    void DeleteAllShapes();
-    void DrawOutline(wxDC& dc, double x1, double y1, double x2, double y2);
-    wxPyShape* FindShape(long id);
-    wxPyShapeCanvas* GetCanvas();
-    int GetCount();
-    double GetGridSpacing();
-    int GetMouseTolerance();
-
-    // wxList* GetShapeList();
-    %addmethods {
-        PyObject* GetShapeList() {
-            wxList* list = self->GetShapeList();
-            return wxPy_ConvertList(list, "wxPyShape");
-        }
-    }
-
-    bool GetQuickEditMode();
-    bool GetSnapToGrid();
-    void InsertShape(wxPyShape *shape);
-    bool LoadFile(const wxString& filename);
-
-    // **** Have to deal with wxExpr and wxExprDatabase first...
-    //void OnDatabaseLoad(wxExprDatabase& database);
-    //void OnDatabaseSave(wxExprDatabase& database);
-    //bool OnHeaderLoad(wxExprDatabase& database, wxExpr& expr);
-    //bool OnHeaderSave(wxExprDatabase& database, wxExpr& expr);
-    //bool OnShapeLoad(wxExprDatabase& database, wxPyShape& shape, wxExpr& expr);
-    //bool OnShapeSave(wxExprDatabase& database, wxPyShape& shape, wxExpr& expr);
-
-
-    void ReadContainerGeometry(wxExprDatabase& database);
-    void ReadLines(wxExprDatabase& database);
-    void ReadNodes(wxExprDatabase& database);
-    void RecentreAll(wxDC& dc);
-    void Redraw(wxDC& dc);
-    void RemoveAllShapes();
-    void RemoveShape(wxPyShape* shape);
-    bool SaveFile(const wxString& filename);
-    void SetCanvas(wxPyShapeCanvas* canvas);
-    void SetGridSpacing(double spacing);
-    void SetMouseTolerance(int tolerance);
-    void SetQuickEditMode(bool mode);
-    void SetSnapToGrid(bool snap);
-    void ShowAll(bool show);
-    void Snap(double *OUTPUT, double *OUTPUT);
-
-};
-
-//---------------------------------------------------------------------------
-
-%{
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnBeginDragLeft);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnBeginDragRight);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnEndDragLeft);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnEndDragRight);
-    IMP_PYCALLBACK__BOOL2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnDragLeft);
-    IMP_PYCALLBACK__BOOL2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnDragRight);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnLeftClick);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnRightClick);
-%}
-
-
-class wxPyShapeCanvas : public wxScrolledWindow {
-public:
-    wxPyShapeCanvas(wxWindow* parent = NULL, wxWindowID id = -1,
-                    const wxPoint& pos = wxPyDefaultPosition,
-                    const wxSize& size = wxPyDefaultSize,
-                    long style = wxBORDER);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyShapeCanvas)"
-
-    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
-    %pragma(python) addtomethod = "__init__:#wx._StdOnScrollCallbacks(self)"
-
-    void AddShape(wxPyShape *shape, wxPyShape *addAfter = NULL);
-
-    // ****  Need a typemap for wxClassInfo, or implement wxObject, etc.....
-    wxPyShape* FindShape(double x1, double y, int *OUTPUT,
-                       wxClassInfo *info = NULL, wxPyShape* notImage = NULL);
-
-    wxPyShape * FindFirstSensitiveShape(double x1, double y, int *OUTPUT, int op);
-    wxDiagram* GetDiagram();
-
-    bool GetQuickEditMode();
-    void InsertShape(wxPyShape* shape);
-
-
-    void base_OnBeginDragLeft(double x, double y, int keys = 0);
-    void base_OnBeginDragRight(double x, double y, int keys = 0);
-    void base_OnEndDragLeft(double x, double y, int keys = 0);
-    void base_OnEndDragRight(double x, double y, int keys = 0);
-    void base_OnDragLeft(bool draw, double x, double y, int keys = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys = 0);
-    void base_OnLeftClick(double x, double y, int keys = 0);
-    void base_OnRightClick(double x, double y, int keys = 0);
-
-    void Redraw(wxDC& dc);
-    void RemoveShape(wxPyShape *shape);
-    void SetDiagram(wxDiagram *diagram);
-    void Snap(double *OUTPUT, double *OUTPUT);
-
-};
-
-
-//---------------------------------------------------------------------------
-
-

wxPython/contrib/ogl/oglcanvas.py

@@ -1,232 +0,0 @@
-# This file was created automatically by SWIG.
-import oglcanvasc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-import wx
-class wxDiagramPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,oglcanvasc=oglcanvasc):
-        if self.thisown == 1 :
-            oglcanvasc.delete_wxDiagram(self)
-    def AddShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_AddShape,(self,) + _args, _kwargs)
-        return val
-    def Clear(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_Clear,(self,) + _args, _kwargs)
-        return val
-    def DeleteAllShapes(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_DeleteAllShapes,(self,) + _args, _kwargs)
-        return val
-    def DrawOutline(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_DrawOutline,(self,) + _args, _kwargs)
-        return val
-    def FindShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_FindShape,(self,) + _args, _kwargs)
-        if val: val = wxPyShapePtr(val) 
-        return val
-    def GetCanvas(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetCanvas,(self,) + _args, _kwargs)
-        if val: val = wxPyShapeCanvasPtr(val) 
-        return val
-    def GetCount(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetCount,(self,) + _args, _kwargs)
-        return val
-    def GetGridSpacing(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetGridSpacing,(self,) + _args, _kwargs)
-        return val
-    def GetMouseTolerance(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetMouseTolerance,(self,) + _args, _kwargs)
-        return val
-    def GetShapeList(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetShapeList,(self,) + _args, _kwargs)
-        return val
-    def GetQuickEditMode(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetQuickEditMode,(self,) + _args, _kwargs)
-        return val
-    def GetSnapToGrid(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetSnapToGrid,(self,) + _args, _kwargs)
-        return val
-    def InsertShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_InsertShape,(self,) + _args, _kwargs)
-        return val
-    def LoadFile(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_LoadFile,(self,) + _args, _kwargs)
-        return val
-    def ReadContainerGeometry(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ReadContainerGeometry,(self,) + _args, _kwargs)
-        return val
-    def ReadLines(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ReadLines,(self,) + _args, _kwargs)
-        return val
-    def ReadNodes(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ReadNodes,(self,) + _args, _kwargs)
-        return val
-    def RecentreAll(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_RecentreAll,(self,) + _args, _kwargs)
-        return val
-    def Redraw(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_Redraw,(self,) + _args, _kwargs)
-        return val
-    def RemoveAllShapes(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_RemoveAllShapes,(self,) + _args, _kwargs)
-        return val
-    def RemoveShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_RemoveShape,(self,) + _args, _kwargs)
-        return val
-    def SaveFile(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SaveFile,(self,) + _args, _kwargs)
-        return val
-    def SetCanvas(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetCanvas,(self,) + _args, _kwargs)
-        return val
-    def SetGridSpacing(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetGridSpacing,(self,) + _args, _kwargs)
-        return val
-    def SetMouseTolerance(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetMouseTolerance,(self,) + _args, _kwargs)
-        return val
-    def SetQuickEditMode(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetQuickEditMode,(self,) + _args, _kwargs)
-        return val
-    def SetSnapToGrid(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetSnapToGrid,(self,) + _args, _kwargs)
-        return val
-    def ShowAll(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ShowAll,(self,) + _args, _kwargs)
-        return val
-    def Snap(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_Snap,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxDiagram instance at %s>" % (self.this,)
-class wxDiagram(wxDiagramPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglcanvasc.new_wxDiagram,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxPyShapeCanvasPtr(wxScrolledWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas__setSelf,(self,) + _args, _kwargs)
-        return val
-    def AddShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_AddShape,(self,) + _args, _kwargs)
-        return val
-    def FindShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_FindShape,(self,) + _args, _kwargs)
-        return val
-    def FindFirstSensitiveShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_FindFirstSensitiveShape,(self,) + _args, _kwargs)
-        return val
-    def GetDiagram(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_GetDiagram,(self,) + _args, _kwargs)
-        if val: val = wxDiagramPtr(val) 
-        return val
-    def GetQuickEditMode(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_GetQuickEditMode,(self,) + _args, _kwargs)
-        return val
-    def InsertShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_InsertShape,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def Redraw(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_Redraw,(self,) + _args, _kwargs)
-        return val
-    def RemoveShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_RemoveShape,(self,) + _args, _kwargs)
-        return val
-    def SetDiagram(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_SetDiagram,(self,) + _args, _kwargs)
-        return val
-    def Snap(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_Snap,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyShapeCanvas instance at %s>" % (self.this,)
-class wxPyShapeCanvas(wxPyShapeCanvasPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglcanvasc.new_wxPyShapeCanvas,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyShapeCanvas)
-        #wx._StdWindowCallbacks(self)
-        #wx._StdOnScrollCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/ogl/oglhelpers.cpp

@@ -1,103 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglhelpers.cpp
-// Purpose:     Some Helper functions to help in data conversions in OGL
-//
-// Author:      Robin Dunn
-//
-// Created:     3-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-#include <Python.h>
-#include "helpers.h"
-
-//---------------------------------------------------------------------------
-// This one will work for any class for the VERY generic cases, but beyond that
-// the helper needs to know more about the type.
-
-wxList* wxPy_wxListHelper(PyObject* pyList, char* className) {
-    bool doSave = wxPyRestoreThread();
-    if (!PyList_Check(pyList)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        wxPySaveThread(doSave);
-        return NULL;
-    }
-    int count = PyList_Size(pyList);
-    wxList* list = new wxList;
-    if (! list) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate wxList object");
-        wxPySaveThread(doSave);
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* pyo = PyList_GetItem(pyList, x);
-        wxObject* wxo = NULL;
-
-        if (SWIG_GetPtrObj(pyo, (void **)&wxo, className)) {
-            char errmsg[1024];
-            sprintf(errmsg, "Type error, expected list of %s objects", className);
-            PyErr_SetString(PyExc_TypeError, errmsg);
-            wxPySaveThread(doSave);
-            return NULL;
-        }
-        list->Append(wxo);
-    }
-    wxPySaveThread(doSave);
-    return list;
-}
-
-//---------------------------------------------------------------------------
-
-wxList* wxPy_wxRealPoint_ListHelper(PyObject* pyList) {
-    bool doSave = wxPyRestoreThread();
-    if (!PyList_Check(pyList)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        wxPySaveThread(doSave);
-        return NULL;
-    }
-    int count = PyList_Size(pyList);
-    wxList* list = new wxList;
-    if (! list) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate wxList object");
-        wxPySaveThread(doSave);
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* pyo = PyList_GetItem(pyList, x);
-
-        if (PyTuple_Check(pyo)) {
-            PyObject* o1 = PyNumber_Float(PyTuple_GetItem(pyo, 0));
-            PyObject* o2 = PyNumber_Float(PyTuple_GetItem(pyo, 1));
-
-            double val1 = (o1 ? PyFloat_AsDouble(o1) : 0.0);
-            double val2 = (o2 ? PyFloat_AsDouble(o2) : 0.0);
-
-            list->Append((wxObject*) new wxRealPoint(val1, val2));
-
-        } else {
-            wxRealPoint* wxo = NULL;
-            if (SWIG_GetPtrObj(pyo, (void **)&wxo, "_wxRealPoint_p")) {
-                PyErr_SetString(PyExc_TypeError, "Type error, expected list of wxRealPoint objects or 2-tuples");
-                wxPySaveThread(doSave);
-                return NULL;
-            }
-            list->Append((wxObject*) new wxRealPoint(*wxo));
-        }
-    }
-    wxPySaveThread(doSave);
-    return list;
-}
-
-
-//---------------------------------------------------------------------------
-
-
-
-
-
-
-
-
-

wxPython/contrib/ogl/oglhelpers.h

@@ -1,262 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglhelpers.h
-// Purpose:     Some Helper functions to help in data conversions in OGL
-//
-// Author:      Robin Dunn
-//
-// Created:     9-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __wxp_ogl_helpers__
-#define __wxp_ogl_helpers__
-
-
-#include <wx/ogl/ogl.h>
-#include <wx/ogl/basicp.h>
-#include <wx/ogl/constrnt.h>
-#include <wx/ogl/bmpshape.h>
-#include <wx/ogl/drawn.h>
-
-
-//---------------------------------------------------------------------------
-// Define a macro that will be used in the class definintions below
-
-#define WXSHAPE_DEC_CALLBACKS()       \
-    DEC_PYCALLBACK__                (OnDelete);             \
-    DEC_PYCALLBACK__DC              (OnDraw);               \
-    DEC_PYCALLBACK__DC              (OnDrawContents);       \
-    DEC_PYCALLBACK__DCBOOL          (OnDrawBranches);       \
-    DEC_PYCALLBACK__DC              (OnMoveLinks);          \
-    DEC_PYCALLBACK__DC              (OnErase);              \
-    DEC_PYCALLBACK__DC              (OnEraseContents);      \
-    DEC_PYCALLBACK__DC              (OnHighlight);          \
-    DEC_PYCALLBACK__2DBL2INT        (OnLeftClick);          \
-    DEC_PYCALLBACK__2DBL2INT        (OnLeftDoubleClick);    \
-    DEC_PYCALLBACK__2DBL2INT        (OnRightClick);         \
-    DEC_PYCALLBACK__2DBL            (OnSize);               \
-    DEC_PYCALLBACK_BOOL_DC4DBLBOOL  (OnMovePre);            \
-    DEC_PYCALLBACK__DC4DBLBOOL      (OnMovePost);           \
-    DEC_PYCALLBACK__BOOL2DBL2INT    (OnDragLeft);           \
-    DEC_PYCALLBACK__2DBL2INT        (OnBeginDragLeft);      \
-    DEC_PYCALLBACK__2DBL2INT        (OnEndDragLeft);        \
-    DEC_PYCALLBACK__BOOL2DBL2INT    (OnDragRight);          \
-    DEC_PYCALLBACK__2DBL2INT        (OnBeginDragRight);     \
-    DEC_PYCALLBACK__2DBL2INT        (OnEndDragRight);       \
-    DEC_PYCALLBACK__DC4DBL          (OnDrawOutline);        \
-    DEC_PYCALLBACK__DC              (OnDrawControlPoints);  \
-    DEC_PYCALLBACK__DC              (OnEraseControlPoints); \
-    DEC_PYCALLBACK__DCBOOL          (OnMoveLink);           \
-    DEC_PYCALLBACK__WXCPBOOL2DBL2INT(OnSizingDragLeft);     \
-    DEC_PYCALLBACK__WXCP2DBL2INT    (OnSizingBeginDragLeft);\
-    DEC_PYCALLBACK__WXCP2DBL2INT    (OnSizingEndDragLeft);  \
-    DEC_PYCALLBACK__2DBL            (OnBeginSize);          \
-    DEC_PYCALLBACK__2DBL            (OnEndSize);            \
-                                                            \
-    PYPRIVATE;
-
-
-#define WXSHAPE_IMP_CALLBACKS(CLASS, PARENT)       \
-    IMP_PYCALLBACK__                (CLASS, PARENT,  OnDelete);             \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnDraw);               \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnDrawContents);       \
-    IMP_PYCALLBACK__DCBOOL          (CLASS, PARENT,  OnDrawBranches);       \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnMoveLinks);          \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnErase);              \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnEraseContents);      \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnHighlight);          \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnLeftClick);          \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnLeftDoubleClick);    \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnRightClick);         \
-    IMP_PYCALLBACK__2DBL            (CLASS, PARENT,  OnSize);               \
-    IMP_PYCALLBACK_BOOL_DC4DBLBOOL  (CLASS, PARENT,  OnMovePre);            \
-    IMP_PYCALLBACK__DC4DBLBOOL      (CLASS, PARENT,  OnMovePost);           \
-    IMP_PYCALLBACK__BOOL2DBL2INT    (CLASS, PARENT,  OnDragLeft);           \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnBeginDragLeft);      \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnEndDragLeft);        \
-    IMP_PYCALLBACK__BOOL2DBL2INT    (CLASS, PARENT,  OnDragRight);          \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnBeginDragRight);     \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnEndDragRight);       \
-    IMP_PYCALLBACK__DC4DBL          (CLASS, PARENT,  OnDrawOutline);        \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnDrawControlPoints);  \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnEraseControlPoints); \
-    IMP_PYCALLBACK__DCBOOL          (CLASS, PARENT,  OnMoveLink);           \
-    IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PARENT,  OnSizingDragLeft);     \
-    IMP_PYCALLBACK__WXCP2DBL2INT    (CLASS, PARENT,  OnSizingBeginDragLeft);\
-    IMP_PYCALLBACK__WXCP2DBL2INT    (CLASS, PARENT,  OnSizingEndDragLeft);  \
-    IMP_PYCALLBACK__2DBL            (CLASS, PARENT,  OnBeginSize);          \
-    IMP_PYCALLBACK__2DBL            (CLASS, PARENT,  OnEndSize);            \
-
-
-    //  This one may be difficult...
-    //PYCALLBACK__???????       (PARENT,  OnChangeAttachment);
-
-
-
-//---------------------------------------------------------------------------
-// These are prototypes of some helper functions found in oglhelpers.cpp
-
-wxList* wxPy_wxListHelper(PyObject* pyList, char* className);
-wxList* wxPy_wxRealPoint_ListHelper(PyObject* pyList);
-
-
-
-//---------------------------------------------------------------------------
-// Classes that derive from the shapes and such, but which know how to turn
-// virtual callbacks into Python callbacks.
-
-class wxPyShapeCanvas : public wxShapeCanvas {
-public:
-    wxPyShapeCanvas(wxWindow* parent = NULL, wxWindowID id = -1,
-                    const wxPoint& pos = wxPyDefaultPosition,
-                    const wxSize& size = wxPyDefaultSize,
-                    long style = wxBORDER)
-        : wxShapeCanvas(parent, id, pos, size, style) {}
-
-    DEC_PYCALLBACK__2DBLINT(OnBeginDragLeft);
-    DEC_PYCALLBACK__2DBLINT(OnBeginDragRight);
-    DEC_PYCALLBACK__2DBLINT(OnEndDragLeft);
-    DEC_PYCALLBACK__2DBLINT(OnEndDragRight);
-    DEC_PYCALLBACK__BOOL2DBLINT(OnDragLeft);
-    DEC_PYCALLBACK__BOOL2DBLINT(OnDragRight);
-    DEC_PYCALLBACK__2DBLINT(OnLeftClick);
-    DEC_PYCALLBACK__2DBLINT(OnRightClick);
-
-    PYPRIVATE;
-};
-
-
-
-class wxPyShapeEvtHandler : public wxShapeEvtHandler {
-public:
-    wxPyShapeEvtHandler(wxShapeEvtHandler *prev = NULL, wxShape *shape = NULL)
-        : wxShapeEvtHandler(prev, shape) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyShape : public wxShape {
-public:
-    wxPyShape(wxPyShapeCanvas *can = NULL)
-        : wxShape(can) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-
-};
-
-
-class wxPyRectangleShape : public wxRectangleShape {
-public:
-    wxPyRectangleShape(double width = 0.0, double height = 0.0)
-        : wxRectangleShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-class wxPyControlPoint : public wxControlPoint {
-public:
-    wxPyControlPoint(wxPyShapeCanvas *the_canvas = NULL,
-                     wxPyShape *object = NULL,
-                     double size = 0.0, double the_xoffset = 0.0,
-                     double the_yoffset = 0.0, int the_type = 0)
-        : wxControlPoint(the_canvas, object, size,
-                         the_xoffset, the_yoffset, the_type) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-
-class wxPyBitmapShape : public wxBitmapShape {
-public:
-    wxPyBitmapShape() : wxBitmapShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-
-class wxPyDrawnShape : public wxDrawnShape {
-public:
-    wxPyDrawnShape() : wxDrawnShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyCompositeShape : public wxCompositeShape {
-public:
-    wxPyCompositeShape() : wxCompositeShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyDividedShape : public wxDividedShape {
-public:
-    wxPyDividedShape(double width = 0.0, double height = 0.0)
-        : wxDividedShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyDivisionShape : public wxDivisionShape {
-public:
-    wxPyDivisionShape() : wxDivisionShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyEllipseShape : public wxEllipseShape {
-public:
-    wxPyEllipseShape(double width = 0.0, double height = 0.0)
-        : wxEllipseShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyCircleShape : public wxCircleShape {
-public:
-    wxPyCircleShape(double width = 0.0)
-        : wxCircleShape(width) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyLineShape : public wxLineShape {
-public:
-    wxPyLineShape() : wxLineShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyPolygonShape : public wxPolygonShape {
-public:
-    wxPyPolygonShape() : wxPolygonShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyTextShape : public wxTextShape {
-public:
-    wxPyTextShape(double width = 0.0, double height = 0.0)
-        : wxTextShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-#endif
-

wxPython/contrib/ogl/oglshapes.i

@@ -1,574 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglshapes.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     3-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module oglshapes
-
-%{
-#include "helpers.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-%import oglbasic.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-class wxPseudoMetaFile {
-public:
-  wxPseudoMetaFile();
-  ~wxPseudoMetaFile();
-
-    void Draw(wxDC& dc, double xoffset, double yoffset);
-
-    void WriteAttributes(wxExpr *clause, int whichAngle);
-    void ReadAttributes(wxExpr *clause, int whichAngle);
-    void Clear();
-    void Copy(wxPseudoMetaFile& copy);
-    void Scale(double sx, double sy);
-    void ScaleTo(double w, double h);
-    void Translate(double x, double y);
-    void Rotate(double x, double y, double theta);
-    bool LoadFromMetaFile(char* filename, double *width, double *height);
-    void GetBounds(double *minX, double *minY, double *maxX, double *maxY);
-    void CalculateSize(wxDrawnShape* shape);
-
-    // ****  fix these...  is it even possible?  these are lists of various GDI opperations (not the objects...)
-    // wxList& GetOutlineColours();
-    // wxList& GetFillColours();
-    // wxList& GetOps();
-
-    void SetRotateable(bool rot);
-    bool GetRotateable();
-    void SetSize(double w, double h);
-    void SetFillBrush(wxBrush* brush);
-    wxBrush* GetFillBrush();
-    void SetOutlinePen(wxPen* pen);
-    wxPen* GetOutlinePen();
-    void SetOutlineOp(int op);
-    int GetOutlineOp();
-
-
-    bool IsValid();
-    void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
-    void DrawRectangle(const wxRect& rect);
-    void DrawRoundedRectangle(const wxRect& rect, double radius);
-    void DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt);
-    void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
-    void DrawEllipse(const wxRect& rect);
-    void DrawPoint(const wxPoint& pt);
-    void DrawText(const wxString& text, const wxPoint& pt);
-    void DrawLines(int PCOUNT, wxPoint* points);
-    void DrawPolygon(int PCOUNT, wxPoint* points, int flags = 0);
-    void DrawSpline(int PCOUNT, wxPoint* points);
-    void SetClippingRect(const wxRect& rect);
-    void DestroyClippingRect();
-    void SetPen(wxPen* pen, bool isOutline = FALSE);
-    void SetBrush(wxBrush* brush, bool isFill = FALSE);
-    void SetFont(wxFont* font);
-    void SetTextColour(const wxColour& colour);
-    void SetBackgroundColour(const wxColour& colour);
-    void SetBackgroundMode(int mode);
-};
-
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyRectangleShape, wxRectangleShape);
-%}
-
-class wxPyRectangleShape : public wxPyShape {
-public:
-    wxPyRectangleShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyRectangleShape)"
-
-    void SetCornerRadius(double radius);
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyControlPoint, wxControlPoint);
-%}
-
-class wxPyControlPoint : public wxPyRectangleShape {
-public:
-    wxPyControlPoint(wxPyShapeCanvas *the_canvas = NULL,
-                     wxPyShape *object = NULL,
-                     double size = 0.0, double the_xoffset = 0.0,
-                     double the_yoffset = 0.0, int the_type = 0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyControlPoint)"
-
-    void SetCornerRadius(double radius);
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyBitmapShape, wxBitmapShape);
-%}
-
-
-class wxPyBitmapShape : public wxPyRectangleShape {
-public:
-    wxPyBitmapShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyBitmapShape)"
-
-    wxBitmap& GetBitmap();
-    wxString GetFilename();
-    void SetBitmap(const wxBitmap& bitmap);
-    void SetFilename(const wxString& filename);
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyDrawnShape, wxDrawnShape);
-%}
-
-class wxPyDrawnShape : public wxPyRectangleShape {
-public:
-    wxPyDrawnShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyDrawnShape)"
-
-    void CalculateSize();
-    void DestroyClippingRect();
-    void DrawArc(const wxPoint& centrePoint, const wxPoint& startPoint,
-                 const wxPoint& endPoint);
-    void DrawAtAngle(int angle);
-    void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
-    void DrawLine(const wxPoint& point1, const wxPoint& point2);
-    void DrawLines(int PCOUNT, wxPoint* points);
-    void DrawPoint(const wxPoint& point);
-    void DrawPolygon(int PCOUNT, wxPoint* points, int flags = 0);
-    void DrawRectangle(const wxRect& rect);
-    void DrawRoundedRectangle(const wxRect& rect, double radius);
-    void DrawSpline(int PCOUNT, wxPoint* points);
-    void DrawText(const wxString& text, const wxPoint& point);
-    int GetAngle();
-
-    wxPseudoMetaFile& GetMetaFile();
-
-    double GetRotation();
-    bool LoadFromMetaFile(char * filename);
-    void Rotate(double x, double y, double theta);
-    void SetClippingRect(const wxRect& rect);
-    void SetDrawnBackgroundColour(const wxColour& colour);
-    void SetDrawnBackgroundMode(int mode);
-    void SetDrawnBrush(wxBrush* pen, bool isOutline = FALSE);
-    void SetDrawnFont(wxFont* font);
-    void SetDrawnPen(wxPen* pen, bool isOutline = FALSE);
-    void SetDrawnTextColour(const wxColour& colour);
-    void Scale(double sx, double sy);
-    void SetSaveToFile(bool save);
-    void Translate(double x, double y);
-
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-
-};
-
-
-//---------------------------------------------------------------------------
-
-class wxOGLConstraint  {
-public:
-    //wxOGLConstraint(int type, wxPyShape *constraining, wxList& constrained);
-    %addmethods {
-        wxOGLConstraint(int type, wxPyShape *constraining, PyObject* constrained) {
-            wxList* list = wxPy_wxListHelper(constrained, "_wxPyShape_p");
-            wxOGLConstraint* rv = new wxOGLConstraint(type, constraining, *list);
-            delete list;
-            return rv;
-        }
-    }
-    ~wxOGLConstraint();
-
-    bool Evaluate();
-    void SetSpacing(double x, double y);
-    bool Equals(double a, double b);
-
-};
-
-
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyCompositeShape, wxCompositeShape);
-%}
-
-class wxPyCompositeShape : public wxPyRectangleShape {
-public:
-    wxPyCompositeShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyCompositeShape)"
-
-    void AddChild(wxPyShape *child, wxPyShape *addAfter = NULL);
-
-    wxOGLConstraint * AddConstraint(wxOGLConstraint *constraint);
-
-
-    //wxOGLConstraint * AddConstraint(int type,
-    //                                wxPyShape *constraining,
-    //                                wxList& constrained);
-    %addmethods {
-        wxOGLConstraint * AddConstrainedShapes(int type, wxPyShape *constraining,
-                                               PyObject* constrained) {
-            wxList* list = wxPy_wxListHelper(constrained, "_wxPyShape_p");
-            wxOGLConstraint* rv = self->AddConstraint(type, constraining, *list);
-            delete list;
-            return rv;
-        }
-    }
-
-    %name(AddSimpleConstraint)wxOGLConstraint* AddConstraint(int type,
-                                                             wxPyShape *constraining,
-                                                             wxPyShape *constrained);
-
-    void CalculateSize();
-    bool ContainsDivision(wxPyDivisionShape *division);
-    void DeleteConstraint(wxOGLConstraint *constraint);
-    void DeleteConstraintsInvolvingChild(wxPyShape *child);
-
-    // ****  Needs an output typemap
-    //wxOGLConstraint * FindConstraint(long id, wxPyCompositeShape **actualComposite);
-
-    wxPyShape * FindContainerImage();
-
-    // wxList& GetConstraints();
-    // wxList& GetDivisions();
-    %addmethods {
-        PyObject* GetConstraints() {
-            wxList& list = self->GetConstraints();
-            return wxPy_ConvertList(&list, "wxOGLConstraint");
-        }
-
-        PyObject* GetDivisions() {
-            wxList& list = self->GetDivisions();
-            return wxPy_ConvertList(&list, "wxPyDivisionShape");
-        }
-    }
-
-    void MakeContainer();
-    bool Recompute();
-    void RemoveChild(wxPyShape *child);
-
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-
-};
-
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyDividedShape, wxDividedShape);
-%}
-
-class wxPyDividedShape : public wxPyRectangleShape {
-public:
-    wxPyDividedShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyDividedShape)"
-
-    void EditRegions();
-    void SetRegionSizes();
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-
-};
-
-
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyDivisionShape, wxDivisionShape);
-%}
-
-class wxPyDivisionShape : public wxPyCompositeShape {
-public:
-    wxPyDivisionShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyDivisionShape)"
-
-    void AdjustBottom(double bottom, bool test);
-    void AdjustLeft(double left, bool test);
-    void AdjustRight(double right, bool test);
-    void AdjustTop(double top, bool test);
-    void Divide(int direction);
-    void EditEdge(int side);
-    wxPyDivisionShape * GetBottomSide();
-    int GetHandleSide();
-    wxPyDivisionShape * GetLeftSide();
-    wxString GetLeftSideColour();
-    wxPen * GetLeftSidePen();
-    wxPyDivisionShape * GetRightSide();
-    wxPyDivisionShape * GetTopSide();
-    wxPen * GetTopSidePen();
-    void ResizeAdjoining(int side, double newPos, bool test);
-    void PopupMenu(double x, double y);
-    void SetBottomSide(wxPyDivisionShape *shape);
-    void SetHandleSide(int side);
-    void SetLeftSide(wxPyDivisionShape *shape);
-    void SetLeftSideColour(const wxString& colour);
-    void SetLeftSidePen(wxPen *pen);
-    void SetRightSide(wxPyDivisionShape *shape);
-    void SetTopSide(wxPyDivisionShape *shape);
-    void SetTopSideColour(const wxString& colour);
-    void SetTopSidePen(wxPen *pen);
-
-
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-
-};
-
-
-
-//---------------------------------------------------------------------------
-

wxPython/contrib/ogl/oglshapes2.i

@@ -1,369 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglshapes2.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     3-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module oglshapes2
-
-%{
-#include "helpers.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-%import oglbasic.i
-%import oglshapes.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyEllipseShape, wxEllipseShape);
-%}
-
-class wxPyEllipseShape : public wxPyShape {
-public:
-    wxPyEllipseShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyEllipseShape)"
-
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyCircleShape, wxCircleShape);
-%}
-
-class wxPyCircleShape : public wxPyEllipseShape {
-public:
-    wxPyCircleShape(double width = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyCircleShape)"
-
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-class wxArrowHead {
-public:
-    wxArrowHead(int type = 0,
-                int end = 0,
-                double size = 0.0,
-                double dist = 0.0,
-                const char * name = "",
-                wxPseudoMetaFile *mf = NULL,
-                long arrowId = -1);
-    ~wxArrowHead();
-
-    int _GetType();
-    int GetPosition();
-    void SetPosition(int pos);
-    double GetXOffset();
-    double GetYOffset();
-    double GetSpacing();
-    double GetSize();
-    wxString GetName();
-    void SetXOffset(double x);
-    void SetYOffset(double y);
-    wxPseudoMetaFile *GetMetaFile();
-    long GetId();
-    int GetArrowEnd();
-    double GetArrowSize();
-    void SetSize(double size);
-    void SetSpacing(double sp);
-};
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyLineShape, wxLineShape);
-%}
-
-class wxPyLineShape : public wxPyShape {
-public:
-    wxPyLineShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyLineShape)"
-
-    void AddArrow(int type, int end = ARROW_POSITION_END,
-                  double arrowSize = 10.0, double xOffset = 0.0,
-                  char* name = "", wxPseudoMetaFile *mf = NULL,
-                  long arrowId = -1);
-
-    //void AddArrowOrdered(wxArrowHead *arrow, wxList& referenceList, int end);
-    %addmethods {
-        void AddArrowOrdered(wxArrowHead *arrow, PyObject* referenceList, int end) {
-            wxList* list = wxPy_wxListHelper(referenceList, "_wxArrowHead_p");
-            self->AddArrowOrdered(arrow, *list, end);
-            delete list;
-        }
-    }
-    bool ClearArrow(const wxString& name);
-    void ClearArrowsAtPosition(int position = -1);
-    void DrawArrow(wxDC& dc, wxArrowHead *arrow, double xOffset, bool proportionalOffset);
-    %name(DeleteArrowHeadId)bool DeleteArrowHead(long arrowId);
-    bool DeleteArrowHead(int position, const wxString& name);
-    bool DeleteLineControlPoint();
-    void DrawArrows(wxDC& dc);
-    void DrawRegion(wxDC& dc, wxShapeRegion *region, double x, double y);
-    void EraseRegion(wxDC& dc, wxShapeRegion *region, double x, double y);
-    %name(FindArrowHeadId)wxArrowHead * FindArrowHead(long arrowId);
-    wxArrowHead * FindArrowHead(int position, const wxString& name);
-    void FindLineEndPoints(double *OUTPUT, double *OUTPUT,
-                           double *OUTPUT, double *OUTPUT);
-    int FindLinePosition(double x, double y);
-    double FindMinimumWidth();
-    void FindNth(wxPyShape *image, int *OUTPUT, int *OUTPUT, bool incoming);
-    int GetAttachmentFrom();
-    int GetAttachmentTo();
-    void GetEnds(double *OUTPUT, double *OUTPUT, double *OUTPUT, double *OUTPUT);
-    wxPyShape * GetFrom();
-    void GetLabelPosition(int position, double *OUTPUT, double *OUTPUT);
-    wxPoint * GetNextControlPoint(wxPyShape *shape);
-    wxPyShape * GetTo();
-    void Initialise();
-    void InsertLineControlPoint(wxDC* dc);
-    bool IsEnd(wxPyShape *shape);
-    bool IsSpline();
-    void MakeLineControlPoints(int n);
-
-    void SetAttachmentFrom(int fromAttach);
-    void SetAttachments(int fromAttach, int toAttach);
-    void SetAttachmentTo(int toAttach);
-    void SetEnds(double x1, double y1, double x2, double y2);
-    void SetFrom(wxPyShape *object);
-    void SetIgnoreOffsets(bool ignore);
-    void SetSpline(bool spline);
-    void SetTo(wxPyShape *object);
-    void Straighten(wxDC* dc = NULL);
-    void Unlink();
-
-
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyPolygonShape, wxPolygonShape);
-%}
-
-class wxPyPolygonShape : public wxPyShape {
-public:
-    wxPyPolygonShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyPolygonShape)"
-
-
-    // void Create(wxList* points);
-    %addmethods {
-        PyObject* Create(PyObject* points) {
-            wxList* list = wxPy_wxRealPoint_ListHelper(points);
-            if (list) {
-                self->Create(list);
-                Py_INCREF(Py_None);
-                return Py_None;
-            }
-            else return NULL;
-        }
-    }
-
-    void AddPolygonPoint(int pos = 0);
-    void CalculatePolygonCentre();
-    void DeletePolygonPoint(int pos = 0);
-
-    // wxList* GetPoints();
-    %addmethods {
-        PyObject* GetPoints() {
-            wxList* list = self->GetPoints();
-            return wxPy_ConvertList(list, "wxRealPoint");
-        }
-    }
-
-    void UpdateOriginalPoints();
-
-
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyTextShape, wxTextShape);
-%}
-
-class wxPyTextShape : public wxPyRectangleShape {
-public:
-    wxPyTextShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyTextShape)"
-
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-
-};
-//---------------------------------------------------------------------------

wxPython/contrib/ogl/oglshapes2.py

@@ -1,774 +0,0 @@
-# This file was created automatically by SWIG.
-import oglshapes2c
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-
-from oglbasic import *
-
-from oglshapes import *
-import wx
-class wxPyEllipseShapePtr(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyEllipseShape instance at %s>" % (self.this,)
-class wxPyEllipseShape(wxPyEllipseShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyEllipseShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyEllipseShape)
-
-
-
-
-class wxPyCircleShapePtr(wxPyEllipseShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyCircleShape instance at %s>" % (self.this,)
-class wxPyCircleShape(wxPyCircleShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyCircleShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyCircleShape)
-
-
-
-
-class wxArrowHeadPtr :
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,oglshapes2c=oglshapes2c):
-        if self.thisown == 1 :
-            oglshapes2c.delete_wxArrowHead(self)
-    def _GetType(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead__GetType,(self,) + _args, _kwargs)
-        return val
-    def GetPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetPosition,(self,) + _args, _kwargs)
-        return val
-    def SetPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetPosition,(self,) + _args, _kwargs)
-        return val
-    def GetXOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetXOffset,(self,) + _args, _kwargs)
-        return val
-    def GetYOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetYOffset,(self,) + _args, _kwargs)
-        return val
-    def GetSpacing(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetSpacing,(self,) + _args, _kwargs)
-        return val
-    def GetSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetSize,(self,) + _args, _kwargs)
-        return val
-    def GetName(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetName,(self,) + _args, _kwargs)
-        return val
-    def SetXOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetXOffset,(self,) + _args, _kwargs)
-        return val
-    def SetYOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetYOffset,(self,) + _args, _kwargs)
-        return val
-    def GetMetaFile(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetMetaFile,(self,) + _args, _kwargs)
-        if val: val = wxPseudoMetaFilePtr(val) 
-        return val
-    def GetId(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetId,(self,) + _args, _kwargs)
-        return val
-    def GetArrowEnd(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetArrowEnd,(self,) + _args, _kwargs)
-        return val
-    def GetArrowSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetArrowSize,(self,) + _args, _kwargs)
-        return val
-    def SetSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetSize,(self,) + _args, _kwargs)
-        return val
-    def SetSpacing(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetSpacing,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxArrowHead instance at %s>" % (self.this,)
-class wxArrowHead(wxArrowHeadPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxArrowHead,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxPyLineShapePtr(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def AddArrow(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_AddArrow,(self,) + _args, _kwargs)
-        return val
-    def AddArrowOrdered(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_AddArrowOrdered,(self,) + _args, _kwargs)
-        return val
-    def ClearArrow(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_ClearArrow,(self,) + _args, _kwargs)
-        return val
-    def ClearArrowsAtPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_ClearArrowsAtPosition,(self,) + _args, _kwargs)
-        return val
-    def DrawArrow(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DrawArrow,(self,) + _args, _kwargs)
-        return val
-    def DeleteArrowHeadId(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DeleteArrowHeadId,(self,) + _args, _kwargs)
-        return val
-    def DeleteArrowHead(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DeleteArrowHead,(self,) + _args, _kwargs)
-        return val
-    def DeleteLineControlPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DeleteLineControlPoint,(self,) + _args, _kwargs)
-        return val
-    def DrawArrows(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DrawArrows,(self,) + _args, _kwargs)
-        return val
-    def DrawRegion(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DrawRegion,(self,) + _args, _kwargs)
-        return val
-    def EraseRegion(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_EraseRegion,(self,) + _args, _kwargs)
-        return val
-    def FindArrowHeadId(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindArrowHeadId,(self,) + _args, _kwargs)
-        if val: val = wxArrowHeadPtr(val) 
-        return val
-    def FindArrowHead(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindArrowHead,(self,) + _args, _kwargs)
-        if val: val = wxArrowHeadPtr(val) 
-        return val
-    def FindLineEndPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindLineEndPoints,(self,) + _args, _kwargs)
-        return val
-    def FindLinePosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindLinePosition,(self,) + _args, _kwargs)
-        return val
-    def FindMinimumWidth(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindMinimumWidth,(self,) + _args, _kwargs)
-        return val
-    def FindNth(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindNth,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetAttachmentFrom,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetAttachmentTo,(self,) + _args, _kwargs)
-        return val
-    def GetEnds(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetEnds,(self,) + _args, _kwargs)
-        return val
-    def GetFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetFrom,(self,) + _args, _kwargs)
-        if val: val = wxPyShapePtr(val) 
-        return val
-    def GetLabelPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetLabelPosition,(self,) + _args, _kwargs)
-        return val
-    def GetNextControlPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetNextControlPoint,(self,) + _args, _kwargs)
-        if val: val = wxPointPtr(val) 
-        return val
-    def GetTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetTo,(self,) + _args, _kwargs)
-        if val: val = wxPyShapePtr(val) 
-        return val
-    def Initialise(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_Initialise,(self,) + _args, _kwargs)
-        return val
-    def InsertLineControlPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_InsertLineControlPoint,(self,) + _args, _kwargs)
-        return val
-    def IsEnd(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_IsEnd,(self,) + _args, _kwargs)
-        return val
-    def IsSpline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_IsSpline,(self,) + _args, _kwargs)
-        return val
-    def MakeLineControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_MakeLineControlPoints,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetAttachmentFrom,(self,) + _args, _kwargs)
-        return val
-    def SetAttachments(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetAttachments,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetAttachmentTo,(self,) + _args, _kwargs)
-        return val
-    def SetEnds(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetEnds,(self,) + _args, _kwargs)
-        return val
-    def SetFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetFrom,(self,) + _args, _kwargs)
-        return val
-    def SetIgnoreOffsets(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetIgnoreOffsets,(self,) + _args, _kwargs)
-        return val
-    def SetSpline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetSpline,(self,) + _args, _kwargs)
-        return val
-    def SetTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetTo,(self,) + _args, _kwargs)
-        return val
-    def Straighten(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_Straighten,(self,) + _args, _kwargs)
-        return val
-    def Unlink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_Unlink,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyLineShape instance at %s>" % (self.this,)
-class wxPyLineShape(wxPyLineShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyLineShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyLineShape)
-
-
-
-
-class wxPyPolygonShapePtr(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def Create(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_Create,(self,) + _args, _kwargs)
-        return val
-    def AddPolygonPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_AddPolygonPoint,(self,) + _args, _kwargs)
-        return val
-    def CalculatePolygonCentre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_CalculatePolygonCentre,(self,) + _args, _kwargs)
-        return val
-    def DeletePolygonPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_DeletePolygonPoint,(self,) + _args, _kwargs)
-        return val
-    def GetPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_GetPoints,(self,) + _args, _kwargs)
-        return val
-    def UpdateOriginalPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_UpdateOriginalPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyPolygonShape instance at %s>" % (self.this,)
-class wxPyPolygonShape(wxPyPolygonShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyPolygonShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyPolygonShape)
-
-
-
-
-class wxPyTextShapePtr(wxPyRectangleShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def base_OnDelete(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDelete,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyTextShape instance at %s>" % (self.this,)
-class wxPyTextShape(wxPyTextShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyTextShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyTextShape)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/ogl/stub.cpp

@@ -1,24 +0,0 @@
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-
-
-#ifdef __cplusplus
-extern "C"
-#endif
-SWIGEXPORT(void) initoglc() {
-}
-
-

wxPython/contrib/stc/.cvsignore

@@ -1,6 +0,0 @@
-Makefile
-Makefile
-contrib
-stc_c.exp
-stc_c.ilk
-stc_c.pch

wxPython/contrib/stc/README.txt

@@ -1,7 +0,0 @@
-Since STC is not always bundled with distributions of wxWindows, in
-order for it to be a standard part of wxPython I need to bundle it
-here.  The contents of the contrib directory are copies of the
-relevant parts of the main contrib directory in wxWindows.  The
-build.py script in this directory will also build the needed files
-from there, so you no longer have to worry about aquiring and building
-additional libraries beyond wxWindows itself.

wxPython/contrib/stc/_stcextras.py

@@ -1,4 +0,0 @@
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-
-wx.wxStyledTextEventPtr       = wxStyledTextEventPtr
-wx.wxStyledTextCtrlPtr        = wxStyledTextCtrlPtr

wxPython/contrib/stc/stc.py

@@ -1,7 +0,0 @@
-
-# The name "stc.cpp" was causing the debugger to get confused with the
-# same module name in the stc library, so I changed the name of this
-# one to stc_.cpp and this little stub to make the "stc" Python module
-# name still usesable for everything that matters.
-
-from stc_ import *

wxPython/contrib/stc/stc_.i

@@ -1,105 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        stc.i
-// Purpose:     Wrappers for the wxStyledTextCtrl.
-//
-// Author:      Robin Dunn
-//
-// Created:     12-Oct-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 2000 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module stc_
-
-
-%{
-#include "helpers.h"
-#include "wx/stc/stc.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern _defs.i
-%extern events.i
-%extern controls.i
-
-
-//----------------------------------------------------------------------
-// Get all our defs from the REAL header file.
-
-%include stc.h
-//%include SciLexer.h
-
-//----------------------------------------------------------------------
-// Python functions to act like the event macros
-
-%pragma(python) code = "
-def EVT_STC_CHANGE(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_CHANGE, fn)
-
-def EVT_STC_STYLENEEDED(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_STYLENEEDED, fn)
-
-def EVT_STC_CHARADDED(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_CHARADDED, fn)
-
-def EVT_STC_UPDATEUI(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_UPDATEUI, fn)
-
-def EVT_STC_SAVEPOINTREACHED(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_SAVEPOINTREACHED, fn)
-
-def EVT_STC_SAVEPOINTLEFT(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_SAVEPOINTLEFT, fn)
-
-def EVT_STC_ROMODIFYATTEMPT(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_ROMODIFYATTEMPT, fn)
-
-def EVT_STC_DOUBLECLICK(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_DOUBLECLICK, fn)
-
-def EVT_STC_MODIFIED(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_MODIFIED, fn)
-
-def EVT_STC_KEY(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_KEY, fn)
-
-def EVT_STC_MACRORECORD(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_MACRORECORD, fn)
-
-def EVT_STC_MARGINCLICK(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_MARGINCLICK, fn)
-
-def EVT_STC_NEEDSHOWN(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_NEEDSHOWN, fn)
-
-def EVT_STC_POSCHANGED(win, id, fn):
-    win.Connect(id, -1, wxEVT_STC_POSCHANGED, fn)
-
-
-"
-
-//----------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-%}
-
-
-//----------------------------------------------------------------------
-
-%pragma(python) include="_stcextras.py";
-
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-
-

wxPython/contrib/stc/stub.cpp

@@ -1,23 +0,0 @@
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-
-#ifdef __cplusplus
-extern "C"
-#endif
-SWIGEXPORT(void) initstc_c() {
-}
-
-

wxPython/demo/.cvsignore

@@ -1,7 +0,0 @@
-*.pyc
-.emacs.desktop
-b.bat
-hangman_dict.txt
-setup.bat
-test.out
-tmphtml.txt

wxPython/demo/About.py

@@ -1,62 +0,0 @@
-import sys, string
-
-from   wxPython.wx       import *
-from   wxPython.html     import *
-import wxPython.lib.wxpTag
-
-#---------------------------------------------------------------------------
-
-class MyAboutBox(wxDialog):
-    text = '''
-<html>
-<body bgcolor="#AC76DE">
-<center><table bgcolor="#458154" width="100%%" cellspacing="0"
-cellpadding="0" border="1">
-<tr>
-    <td align="center">
-    <h1>wxPython %s</h1>
-    Running on Python %s<br>
-    </td>
-</tr>
-</table>
-
-<p><b>wxPython</b> is a Python extension module that
-encapsulates the wxWindows GUI classes.</p>
-
-<p>This demo shows off some of the capabilities
-of <b>wxPython</b>.  Select items from the menu or tree control,
-sit back and enjoy.  Be sure to take a peek at the source code for each
-demo item so you can learn how to use the classes yourself.</p>
-
-<p><b>wxPython</b> is brought to you by <b>Robin Dunn</b> and<br>
-<b>Total Control Software</b>, Copyright (c) 1997-2000.</p>
-
-<p>
-<font size="-1">Please see <i>license.txt</i> for licensing information.</font>
-</p>
-
-<p><wxp class="wxButton">
-    <param name="label" value="Okay">
-    <param name="id"    value="wxID_OK">
-</wxp></p>
-</center>
-</body>
-</html>
-'''
-    def __init__(self, parent):
-        wxDialog.__init__(self, parent, -1, 'About the wxPython demo',)
-        html = wxHtmlWindow(self, -1, size=(420, -1))
-        py_version = string.split(sys.version)[0]
-        html.SetPage(self.text % (wx.__version__, py_version))
-        ir = html.GetInternalRepresentation()
-        html.SetSize( (ir.GetWidth()+5, ir.GetHeight()+5) )
-        self.SetClientSize(html.GetSize())
-        self.CentreOnParent(wxBOTH)
-
-#---------------------------------------------------------------------------
-
-
-
-
-
-

wxPython/demo/ActiveXWrapper_Acrobat.py

@@ -1,130 +0,0 @@
-"""
-<html><body>
-This demo shows how to embed an ActiveX control in a wxPython application, (Win32 only.)
-<p>
-The MakeActiveXClass function dynamically builds a new Class on the fly, that has the
-same signature and semantics as wxWindow.  This means that when you call the function
-you get back a new class that you can use just like wxWindow, (set the size and position,
-use in a sizer, etc.) except its contents will be the COM control.
-<p>
-This demo embeds the Adobe Acrobat Reader, and gives you some buttons for opening a PDF
-file, changing pages, etc. that show how to call methods on the COM object.  If you don't
-have Acrobat Reader 4.0 installed it won't work.
-</body></html>
-"""
-
-from wxPython.wx import *
-
-if wxPlatform == '__WXMSW__':
-    from wxPython.lib.activexwrapper import MakeActiveXClass
-    import win32com.client.gencache
-
-    try:
-        acrobat = win32com.client.gencache.EnsureModule('{CA8A9783-280D-11CF-A24D-444553540000}', 0x0, 1, 3)
-    except:
-        raise ImportError("Can't load PDF.OCX, install Acrobat 4.0")
-
-
-
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent):
-        wxPanel.__init__(self, parent, -1)
-        self.pdf = None
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        btnSizer = wxBoxSizer(wxHORIZONTAL)
-
-        # this function creates a new class that can be used as
-        # a wxWindow, but contains the given ActiveX control.
-        ActiveXWrapper = MakeActiveXClass(acrobat.Pdf)
-
-        # create an instance of the new class
-        self.pdf = ActiveXWrapper( self, -1, style=wxSUNKEN_BORDER)
-
-        sizer.Add(self.pdf, 1, wxEXPAND)
-
-        btn = wxButton(self, wxNewId(), "Open PDF File")
-        EVT_BUTTON(self, btn.GetId(), self.OnOpenButton)
-        btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), "<-- Previous Page")
-        EVT_BUTTON(self, btn.GetId(), self.OnPrevPageButton)
-        btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), "Next Page -->")
-        EVT_BUTTON(self, btn.GetId(), self.OnNextPageButton)
-        btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
-
-
-        btnSizer.Add(50, -1, 2, wxEXPAND)
-        sizer.Add(btnSizer, 0, wxEXPAND)
-
-        self.SetSizer(sizer)
-        self.SetAutoLayout(true)
-
-    def __del__(self):
-        if self.pdf:
-            self.pdf.Cleanup()
-            self.pdf = None
-
-
-
-    def OnOpenButton(self, event):
-        dlg = wxFileDialog(self, wildcard="*.pdf")
-        if dlg.ShowModal() == wxID_OK:
-            wxBeginBusyCursor()
-            self.pdf.LoadFile(dlg.GetPath())
-            wxEndBusyCursor()
-
-        dlg.Destroy()
-
-
-    def OnPrevPageButton(self, event):
-        self.pdf.gotoPreviousPage()
-
-
-    def OnNextPageButton(self, event):
-        self.pdf.gotoNextPage()
-
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    if wxPlatform == '__WXMSW__':
-        win = TestPanel(nb)
-        return win
-    else:
-        dlg = wxMessageDialog(frame, 'This demo only works on MSW.',
-                          'Sorry', wxOK | wxICON_INFORMATION)
-        dlg.ShowModal()
-        dlg.Destroy()
-
-
-overview = __doc__
-
-#----------------------------------------------------------------------
-
-
-if __name__ == '__main__':
-    class TestFrame(wxFrame):
-        def __init__(self):
-            wxFrame.__init__(self, None, -1, "ActiveX test -- Acrobat", size=(640, 480),
-                             style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
-            self.tp = TestPanel(self, sys.stdout)
-            EVT_CLOSE(self, self.OnCloseWindow)
-
-        def OnCloseWindow(self, event):
-            self.tp.pdf.Cleanup()
-            self.Destroy()
-
-
-    app = wxPySimpleApp()
-    frame = TestFrame()
-    frame.Show(true)
-    app.MainLoop()
-
-
-

wxPython/demo/ActiveXWrapper_IE.py

@@ -1,205 +0,0 @@
-"""
-<html><body>
-This demo shows how to embed an ActiveX control in a wxPython
-application, (Win32 only.)
-
-<p>
-The MakeActiveXClass function dynamically builds a new Class on the
-fly, that has the same signature and semantics as wxWindow.  This
-means that when you call the function you get back a new class that
-you can use just like wxWindow, (set the size and position, use in a
-sizer, etc.) except its contents will be the COM control.
-
-<p>
-This demo embeds the Internet Exploer WebBrowser control, and shows
-how to receive events from the COM control.  (The title bar and status
-bar are updated as pages change, in addition to the log messages being
-shown.)
-</body></html>
-"""
-
-from wxPython.wx import *
-
-if wxPlatform == '__WXMSW__':
-    from wxPython.lib.activexwrapper import MakeActiveXClass
-    import win32com.client.gencache
-
-    try:
-        browserModule = win32com.client.gencache.EnsureModule("{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}", 0, 1, 1)
-    except:
-        raise ImportError("IE4 or greater does not appear to be installed.")
-
-
-#----------------------------------------------------------------------
-
-class TestPanel(wxWindow):
-    def __init__(self, parent, log, frame=None):
-        wxWindow.__init__(self, parent, -1)#, style=wxCLIP_CHILDREN)
-        self.ie = None
-        self.log = log
-        self.current = "http://wxPython.org/"
-        self.frame = frame
-        if frame:
-            self.titleBase = frame.GetTitle()
-
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        btnSizer = wxBoxSizer(wxHORIZONTAL)
-
-        # Make a new class that derives from the WebBrowser class in the
-        # COM module imported above.  This class also derives from wxWindow and
-        # implements the machinery needed to integrate the two worlds.
-        theClass = MakeActiveXClass(browserModule.WebBrowser,
-                                    eventObj = self)
-
-        # Create an instance of that class
-        self.ie = theClass(self, -1, style=wxSUNKEN_BORDER)
-
-
-        #btn = wxButton(self, wxNewId(), " Open ")
-        #EVT_BUTTON(self, btn.GetId(), self.OnOpenButton)
-        #btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), " Home ")
-        EVT_BUTTON(self, btn.GetId(), self.OnHomeButton)
-        btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), " <-- ")
-        EVT_BUTTON(self, btn.GetId(), self.OnPrevPageButton)
-        btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), " --> ")
-        EVT_BUTTON(self, btn.GetId(), self.OnNextPageButton)
-        btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        txt = wxStaticText(self, -1, "Location:")
-        btnSizer.Add(txt, 0, wxCENTER|wxALL, 5)
-
-        self.location = wxComboBox(self, wxNewId(), "", style=wxCB_DROPDOWN)
-        EVT_COMBOBOX(self, self.location.GetId(), self.OnLocationSelect)
-        EVT_KEY_UP(self.location, self.OnLocationKey)
-        #EVT_CHAR(self.location, self.IgnoreReturn)
-        btnSizer.Add(self.location, 1, wxEXPAND|wxALL, 5)
-
-        sizer.Add(btnSizer, 0, wxEXPAND)
-        sizer.Add(self.ie, 1, wxEXPAND)
-
-        self.ie.Navigate(self.current)
-        self.location.Append(self.current)
-
-        self.SetSizer(sizer)
-        self.SetAutoLayout(true)
-        EVT_SIZE(self, self.OnSize)
-
-
-    def OnSize(self, evt):
-        self.Layout()
-
-    def __del__(self):
-        if self.ie:
-            self.ie.Cleanup()
-            self.ie = None
-
-    def OnLocationSelect(self, evt):
-        url = self.location.GetStringSelection()
-        self.log.write('OnLocationSelect: %s\n' % url)
-        self.ie.Navigate(url)
-
-    def OnLocationKey(self, evt):
-        if evt.KeyCode() == WXK_RETURN:
-            URL = self.location.GetValue()
-            self.location.Append(URL)
-            self.ie.Navigate(URL)
-        else:
-            evt.Skip()
-
-    def IgnoreReturn(self, evt):
-        print 'IgnoreReturn'
-        if evt.KeyCode() != WXK_RETURN:
-            evt.Skip()
-
-    def OnOpenButton(self, event):
-        dlg = wxTextEntryDialog(self, "Open Location",
-                                "Enter a full URL or local path",
-                                self.current, wxOK|wxCANCEL)
-        dlg.CentreOnParent()
-        if dlg.ShowModal() == wxID_OK:
-            self.current = dlg.GetValue()
-            self.ie.Navigate(self.current)
-        dlg.Destroy()
-
-    def OnHomeButton(self, event):
-        self.ie.GoHome()    ## ET Phone Home!
-
-    def OnPrevPageButton(self, event):
-        self.ie.GoBack()
-
-
-    def OnNextPageButton(self, event):
-        self.ie.GoForward()
-
-
-    # The following event handlers are called by the web browser COM
-    # control since  we passed self to MakeActiveXClass.  It will look
-    # here for matching attributes and call them if they exist.  See the
-    # module generated by makepy for details of method names, etc.
-    def OnBeforeNavigate2(self, pDisp, URL, *args):
-        self.log.write('OnBeforeNavigate2: %s\n' % URL)
-
-    def OnNavigateComplete2(self, pDisp, URL):
-        self.log.write('OnNavigateComplete2: %s\n' % URL)
-        self.current = URL
-        self.location.SetValue(URL)
-
-    def OnTitleChange(self, text):
-        self.log.write('OnTitleChange: %s\n' % text)
-        if self.frame:
-            self.frame.SetTitle(self.titleBase + ' -- ' + text)
-
-    def OnStatusTextChange(self, text):
-        self.log.write('OnStatusTextChange: %s\n' % text)
-        if self.frame:
-            self.frame.SetStatusText(text)
-
-
-#----------------------------------------------------------------------
-# for the demo framework...
-
-def runTest(frame, nb, log):
-    if wxPlatform == '__WXMSW__':
-        win = TestPanel(nb, log, frame)
-        return win
-    else:
-        dlg = wxMessageDialog(frame, 'This demo only works on MSW.',
-                          'Sorry', wxOK | wxICON_INFORMATION)
-        dlg.ShowModal()
-        dlg.Destroy()
-
-
-overview = __doc__
-
-#----------------------------------------------------------------------
-
-
-if __name__ == '__main__':
-    class TestFrame(wxFrame):
-        def __init__(self):
-            wxFrame.__init__(self, None, -1, "ActiveX test -- Internet Explorer",
-                             size=(640, 480),
-                             style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
-            self.CreateStatusBar()
-            self.tp = TestPanel(self, sys.stdout, self)
-            EVT_CLOSE(self, self.OnCloseWindow)
-
-        def OnCloseWindow(self, event):
-            self.tp.ie.Cleanup()
-            self.Destroy()
-
-
-    app = wxPySimpleApp()
-    frame = TestFrame()
-    frame.Show(true)
-    app.MainLoop()
-
-
-

wxPython/demo/ColorPanel.py

@@ -1,13 +0,0 @@
-
-from wxPython.wx import *
-
-#---------------------------------------------------------------------------
-
-
-class ColoredPanel(wxWindow):
-    def __init__(self, parent, color):
-        wxWindow.__init__(self, parent, -1,
-                          wxDefaultPosition, wxDefaultSize, wxRAISED_BORDER)
-        self.SetBackgroundColour(color)
-
-#---------------------------------------------------------------------------

wxPython/demo/CustomDragAndDrop.py

@@ -1,285 +0,0 @@
-
-from wxPython.wx import *
-
-import cPickle
-
-#----------------------------------------------------------------------
-
-
-class DoodlePad(wxWindow):
-    def __init__(self, parent, log):
-        wxWindow.__init__(self, parent, -1, style=wxSUNKEN_BORDER)
-        self.log = log
-        self.SetBackgroundColour(wxWHITE)
-        self.lines = []
-        self.x = self.y = 0
-        self.SetCursor(wxStockCursor(wxCURSOR_PENCIL))
-
-        EVT_LEFT_DOWN(self, self.OnLeftDown)
-        EVT_LEFT_UP(self, self.OnLeftUp)
-        EVT_RIGHT_UP(self, self.OnRightUp)
-        EVT_MOTION(self, self.OnMotion)
-        EVT_PAINT(self, self.OnPaint)
-
-
-    def OnPaint(self, event):
-        dc = wxPaintDC(self)
-        self.DrawSavedLines(dc)
-
-    def DrawSavedLines(self, dc):
-        dc.BeginDrawing()
-        dc.SetPen(wxPen(wxBLUE, 3))
-        for line in self.lines:
-            for coords in line:
-                apply(dc.DrawLine, coords)
-        dc.EndDrawing()
-
-
-    def OnLeftDown(self, event):
-        if event.ControlDown():
-            self.StartDragOpperation()
-        else:
-            self.curLine = []
-            self.x, self.y = event.GetPositionTuple()
-            self.CaptureMouse()
-
-
-    def OnLeftUp(self, event):
-        self.lines.append(self.curLine)
-        self.curLine = []
-        self.ReleaseMouse()
-
-    def OnRightUp(self, event):
-        self.lines = []
-        self.Refresh()
-
-    def OnMotion(self, event):
-        if event.Dragging() and not event.ControlDown():
-            dc = wxClientDC(self)
-            dc.BeginDrawing()
-            dc.SetPen(wxPen(wxBLUE, 3))
-            coords = (self.x, self.y) + event.GetPositionTuple()
-            self.curLine.append(coords)
-            apply(dc.DrawLine, coords)
-            self.x, self.y = event.GetPositionTuple()
-            dc.EndDrawing()
-
-
-    def StartDragOpperation(self):
-        # pickle the lines list
-        linesdata = cPickle.dumps(self.lines, 1)
-
-        # create our own data format and use it in a
-        # custom data object
-        ldata = wxCustomDataObject(wxCustomDataFormat("DoodleLines"))
-        ldata.SetData(linesdata)
-
-        # Also create a Bitmap version of the drawing
-        size = self.GetSize()
-        bmp = wxEmptyBitmap(size.width, size.height)
-        dc = wxMemoryDC()
-        dc.SelectObject(bmp)
-        dc.SetBackground(wxWHITE_BRUSH)
-        dc.Clear()
-        self.DrawSavedLines(dc)
-        dc.SelectObject(wxNullBitmap)
-
-        # Now make a data object for the bitmap and also a composite
-        # data object holding both of the others.
-        bdata = wxBitmapDataObject(bmp)
-        data = wxDataObjectComposite()
-        data.Add(ldata)
-        data.Add(bdata)
-
-        # And finally, create the drop source and begin the drag
-        # and drop opperation
-        dropSource = wxDropSource(self)
-        dropSource.SetData(data)
-        self.log.WriteText("Begining DragDrop\n")
-        result = dropSource.DoDragDrop()
-        self.log.WriteText("DragDrop completed: %d\n" % result)
-
-
-
-#----------------------------------------------------------------------
-
-
-class DoodleDropTarget(wxPyDropTarget):
-    def __init__(self, window, log):
-        wxPyDropTarget.__init__(self)
-        self.log = log
-        self.dv = window
-
-        # specify the type of data we will accept
-        self.data = wxCustomDataObject(wxCustomDataFormat("DoodleLines"))
-        self.SetDataObject(self.data)
-
-
-    # some virtual methods that track the progress of the drag
-    def OnEnter(self, x, y, d):
-        self.log.WriteText("OnEnter: %d, %d, %d\n" % (x, y, d))
-        return wxDragCopy
-    def OnLeave(self):
-        self.log.WriteText("OnLeave\n")
-    def OnDrop(self, x, y):
-        self.log.WriteText("OnDrop: %d %d\n" % (x, y))
-        return true
-    #def OnDragOver(self, x, y, d):
-    #    self.log.WriteText("OnDragOver: %d, %d, %d\n" % (x, y, d))
-    #    return wxDragCopy
-
-
-    # Called when OnDrop returns true.  We need to get the data and
-    # do something with it.
-    def OnData(self, x, y, d):
-        self.log.WriteText("OnData: %d, %d, %d\n" % (x, y, d))
-
-        # copy the data from the drag source to out data object
-        if self.GetData():
-            # convert it back to a list of lines and give it to the viewer
-            linesdata = self.data.GetData()
-            lines = cPickle.loads(linesdata)
-            self.dv.SetLines(lines)
-        return d
-
-
-
-
-class DoodleViewer(wxWindow):
-    def __init__(self, parent, log):
-        wxWindow.__init__(self, parent, -1, style=wxSUNKEN_BORDER)
-        self.log = log
-        self.SetBackgroundColour(wxWHITE)
-        self.lines = []
-        self.x = self.y = 0
-        dt = DoodleDropTarget(self, log)
-        self.SetDropTarget(dt)
-        EVT_PAINT(self, self.OnPaint)
-
-    def SetLines(self, lines):
-        self.lines = lines
-        self.Refresh()
-
-    def OnPaint(self, event):
-        dc = wxPaintDC(self)
-        self.DrawSavedLines(dc)
-
-    def DrawSavedLines(self, dc):
-        dc.BeginDrawing()
-        dc.SetPen(wxPen(wxRED, 3))
-        for line in self.lines:
-            for coords in line:
-                apply(dc.DrawLine, coords)
-        dc.EndDrawing()
-
-#----------------------------------------------------------------------
-
-class CustomDnDPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
-
-        sizer = wxBoxSizer(wxHORIZONTAL)
-        text = wxStaticText(self, -1,
-                            "Draw a little picture in this window\n"
-                            "then Ctrl-Drag it to the lower \n"
-                            "window or to another application\n"
-                            "that accepts BMP's as a drop target.\n\n"
-                            "The lower window is accepting a\n"
-                            "custom data type that is a pickled\n"
-                            "Python list of lines data.")
-        sizer.Add(text, 1, wxALL, 10)
-
-        insizer = wxBoxSizer(wxVERTICAL)
-        insizer.Add(DoodlePad(self, log), 1, wxEXPAND|wxALL, 5)
-        insizer.Add(DoodleViewer(self, log), 1, wxEXPAND|wxALL, 5)
-
-        sizer.Add(insizer, 1, wxEXPAND)
-        self.SetAutoLayout(true)
-        self.SetSizer(sizer)
-
-
-
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetAutoLayout(true)
-        sizer = wxBoxSizer(wxVERTICAL)
-
-        msg = "Custom Drag-And-Drop"
-        text = wxStaticText(self, -1, "", style=wxALIGN_CENTRE)
-        text.SetFont(wxFont(24, wxSWISS, wxNORMAL, wxBOLD, false))
-        text.SetLabel(msg)
-        w,h = text.GetTextExtent(msg)
-        text.SetSize(wxSize(w,h+1))
-        text.SetForegroundColour(wxBLUE)
-        sizer.Add(text, 0, wxEXPAND|wxALL, 5)
-        sizer.Add(wxStaticLine(self, -1), 0, wxEXPAND)
-
-        sizer.Add(CustomDnDPanel(self, log), 1, wxEXPAND)
-
-        self.SetSizer(sizer)
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-
-if __name__ == '__main__':
-    import sys
-    class DummyLog:
-        def WriteText(self, text):
-            sys.stdout.write(text)
-
-    class TestApp(wxApp):
-        def OnInit(self):
-            self.MakeFrame()
-            return true
-
-        def MakeFrame(self, event=None):
-            frame = wxFrame(None, -1, "Custom Drag and Drop", size=(550,400))
-            menu = wxMenu()
-            menu.Append(6543, "Window")
-            mb = wxMenuBar()
-            mb.Append(menu, "New")
-            frame.SetMenuBar(mb)
-            EVT_MENU(frame, 6543, self.MakeFrame)
-            panel = TestPanel(frame, DummyLog())
-            frame.Show(true)
-            self.SetTopWindow(frame)
-
-
-
-    app = TestApp(0)
-    app.MainLoop()
-
-#----------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-overview = """\
-This demo shows Drag and Drop using a custom data type and a custom data object.  A type called "DoodleLines" is created and a Python Pickle of a list is actually transfered in the drag and drop opperation.
-
-A second data object is also created containing a bitmap of the image and is made available to any drop target that accepts bitmaps, such as MS Word.
-
-The two data objects are combined in a wxDataObjectComposite and the rest is handled by the framework.
-"""
-

wxPython/demo/DialogUnits.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python
-#----------------------------------------------------------------------------
-# Name:         DialogUnits.py
-# Purpose:      A minimal wxPython program that is a bit smarter than test1.
-#
-# Author:       Robin Dunn
-#
-# Created:      A long time ago, in a galaxy far, far away...
-# RCS-ID:       $Id$
-# Copyright:    (c) 1998 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-
-## import all of the wxPython GUI package
-from wxPython.wx import *
-
-
-#---------------------------------------------------------------------------
-
-## Create a new frame class, derived from the wxPython Frame.
-class MyFrame(wxFrame):
-
-    def __init__(self, parent, id, title):
-        # First, call the base class' __init__ method to create the frame
-        wxFrame.__init__(self, parent, id, title,
-                         wxPoint(100, 100), wxSize(160, 100))
-
-        # Associate some events with methods of this class
-        EVT_SIZE(self, self.OnSize)
-        EVT_MOVE(self, self.OnMove)
-        EVT_CLOSE(self, self.OnCloseWindow)
-
-        # Add a panel and some controls to display the size and position
-        panel = wxPanel(self, -1)
-        wxStaticText(panel, -1, "Size:",
-                     wxDLG_PNT(panel, wxPoint(4, 4)),  wxDefaultSize)
-        wxStaticText(panel, -1, "Pos:",
-                     wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
-        self.sizeCtrl = wxTextCtrl(panel, -1, "",
-                                   wxDLG_PNT(panel, wxPoint(24, 4)),
-                                   wxDLG_SZE(panel, wxSize(36, -1)),
-                                   wxTE_READONLY)
-
-        self.posCtrl = wxTextCtrl(panel, -1, "",
-                                  wxDLG_PNT(panel, wxPoint(24, 16)),
-                                  wxDLG_SZE(panel, wxSize(36, -1)),
-                                  wxTE_READONLY)
-
-        #print wxDLG_PNT(panel, wxPoint(24, 4)), wxDLG_SZE(panel, wxSize(36, -1))
-        #print wxDLG_PNT(panel, wxPoint(24, 16)),wxDLG_SZE(panel, wxSize(36, -1))
-
-
-    # This method is called automatically when the CLOSE event is
-    # sent to this window
-    def OnCloseWindow(self, event):
-        # tell the window to kill itself
-        self.Destroy()
-
-
-    # This method is called by the System when the window is resized,
-    # because of the association above.
-    def OnSize(self, event):
-        size = event.GetSize()
-        self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height))
-
-        # tell the event system to continue looking for an event handler,
-        # so the default handler will get called.
-        event.Skip()
-
-    # This method is called by the System when the window is moved,
-    # because of the association above.
-    def OnMove(self, event):
-        pos = event.GetPosition()
-        self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y))
-
-
-
-#---------------------------------------------------------------------------
-# if running standalone
-
-if __name__ == "__main__":
-    # Every wxWindows application must have a class derived from wxApp
-    class MyApp(wxApp):
-
-        # wxWindows calls this method to initialize the application
-        def OnInit(self):
-
-            # Create an instance of our customized Frame class
-            frame = MyFrame(NULL, -1, "This is a test")
-            frame.Show(true)
-
-            # Tell wxWindows that this is our main window
-            self.SetTopWindow(frame)
-
-            # Return a success flag
-            return true
-
-
-    app = MyApp(0)     # Create an instance of the application class
-    app.MainLoop()     # Tell it to start processing events
-
-
-#---------------------------------------------------------------------------
-# if running as part of the Demo Framework...
-
-def runTest(frame, nb, log):
-    win = MyFrame(frame, -1, "This is a test")
-    frame.otherWin = win
-    win.Show(true)
-
-
-overview = """\
-A simple example that shows how to use Dialog Units.
-"""
-
-#----------------------------------------------------------------------------
-#
-
-
-
-
-
-
-
-
-

wxPython/demo/DragAndDrop.py

@@ -1,196 +0,0 @@
-
-from wxPython.wx import *
-
-#----------------------------------------------------------------------
-
-class ClipTextPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        #self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        sizer.Add(wxStaticText(self, -1,
-                               "Copy/Paste text to/from\n"
-                               "this window and other apps"), 0, wxEXPAND|wxALL, 2)
-
-        self.text = wxTextCtrl(self, -1, "", style=wxTE_MULTILINE|wxHSCROLL)
-        sizer.Add(self.text, 1, wxEXPAND)
-
-        hsz = wxBoxSizer(wxHORIZONTAL)
-        hsz.Add(wxButton(self, 6050, " Copy "), 1, wxEXPAND|wxALL, 2)
-        hsz.Add(wxButton(self, 6051, " Paste "), 1, wxEXPAND|wxALL, 2)
-        sizer.Add(hsz, 0, wxEXPAND)
-        sizer.Add(wxButton(self, 6052, " Copy Bitmap "), 0, wxEXPAND|wxALL, 2)
-
-        EVT_BUTTON(self, 6050, self.OnCopy)
-        EVT_BUTTON(self, 6051, self.OnPaste)
-        EVT_BUTTON(self, 6052, self.OnCopyBitmap)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(sizer)
-
-
-    def OnCopy(self, evt):
-        self.do = wxTextDataObject()
-        self.do.SetText(self.text.GetValue())
-        wxTheClipboard.Open()
-        wxTheClipboard.SetData(self.do)
-        wxTheClipboard.Close()
-
-
-    def OnPaste(self, evt):
-        do = wxTextDataObject()
-        wxTheClipboard.Open()
-        success = wxTheClipboard.GetData(do)
-        wxTheClipboard.Close()
-        if success:
-            self.text.SetValue(do.GetText())
-        else:
-            wxMessageBox("There is no data in the clipboard in the required format",
-                         "Error")
-
-    def OnCopyBitmap(self, evt):
-        dlg = wxFileDialog(self, "Choose a bitmap to copy", wildcard="*.bmp")
-        if dlg.ShowModal() == wxID_OK:
-            bmp = wxBitmap(dlg.GetFilename(), wxBITMAP_TYPE_BMP)
-            bmpdo = wxBitmapDataObject(bmp)
-            wxTheClipboard.Open()
-            wxTheClipboard.SetData(bmpdo)
-            wxTheClipboard.Close()
-
-            wxMessageBox("The bitmap is now in the Clipboard.  Switch to a graphics\n"
-                         "editor and try pasting it in...")
-        dlg.Destroy()
-
-#----------------------------------------------------------------------
-
-class OtherDropTarget(wxPyDropTarget):
-    def __init__(self, window, log):
-        wxPyDropTarget.__init__(self)
-        self.log = log
-        self.do = wxFileDataObject()
-        self.SetDataObject(self.do)
-
-    def OnEnter(self, x, y, d):
-        self.log.WriteText("OnEnter: %d, %d, %d\n" % (x, y, d))
-        return wxDragCopy
-
-    #def OnDragOver(self, x, y, d):
-    #    self.log.WriteText("OnDragOver: %d, %d, %d\n" % (x, y, d))
-    #    return wxDragCopy
-
-    def OnLeave(self):
-        self.log.WriteText("OnLeave\n")
-
-    def OnDrop(self, x, y):
-        self.log.WriteText("OnDrop: %d %d\n" % (x, y))
-        return true
-
-    def OnData(self, x, y, d):
-        self.log.WriteText("OnData: %d, %d, %d\n" % (x, y, d))
-        self.GetData()
-        self.log.WriteText("%s\n" % self.do.GetFilenames())
-        return d
-
-
-
-
-class MyFileDropTarget(wxFileDropTarget):
-    def __init__(self, window, log):
-        wxFileDropTarget.__init__(self)
-        self.window = window
-        self.log = log
-
-    def OnDropFiles(self, x, y, filenames):
-        self.window.SetInsertionPointEnd()
-        self.window.WriteText("\n%d file(s) dropped at %d,%d:\n" %
-                              (len(filenames), x, y))
-        for file in filenames:
-            self.window.WriteText(file + '\n')
-
-
-
-class FileDropPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        #self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        sizer.Add(wxStaticText(self, -1, " \nDrag some files here:"),
-                  0, wxEXPAND|wxALL, 2)
-
-        self.text = wxTextCtrl(self, -1, "",
-                               style = wxTE_MULTILINE|wxHSCROLL|wxTE_READONLY)
-        dt = MyFileDropTarget(self, log)
-        self.text.SetDropTarget(dt)
-        sizer.Add(self.text, 1, wxEXPAND)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(sizer)
-
-
-    def WriteText(self, text):
-        self.text.WriteText(text)
-
-    def SetInsertionPointEnd(self):
-        self.text.SetInsertionPointEnd()
-
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetAutoLayout(true)
-        outsideSizer = wxBoxSizer(wxVERTICAL)
-
-        msg = "Clipboard / Drag-And-Drop"
-        text = wxStaticText(self, -1, "", style=wxALIGN_CENTRE)
-        text.SetFont(wxFont(24, wxSWISS, wxNORMAL, wxBOLD, false))
-        text.SetLabel(msg)
-        w,h = text.GetTextExtent(msg)
-        text.SetSize(wxSize(w,h+1))
-        text.SetForegroundColour(wxBLUE)
-        outsideSizer.Add(text, 0, wxEXPAND|wxALL, 5)
-        outsideSizer.Add(wxStaticLine(self, -1), 0, wxEXPAND)
-
-        inSizer = wxBoxSizer(wxHORIZONTAL)
-        inSizer.Add(ClipTextPanel(self, log), 1, wxEXPAND)
-        inSizer.Add(FileDropPanel(self, log), 1, wxEXPAND)
-
-        outsideSizer.Add(inSizer, 1, wxEXPAND)
-        self.SetSizer(outsideSizer)
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-#----------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-overview = """\
-This demo shows some examples of data transfer through clipboard or drag and drop. In wxWindows, these two ways to transfer data (either between different applications or inside one and the same) are very similar which allows to implement both of them using almost the same code - or, in other words, if you implement drag and drop support for your application, you get clipboard support for free and vice versa.
-
-At the heart of both clipboard and drag and drop operations lies the wxDataObject class. The objects of this class (or, to be precise, classes derived from it) represent the data which is being carried by the mouse during drag and drop operation or copied to or pasted from the clipboard. wxDataObject is a "smart" piece of data because it knows which formats it supports (see GetFormatCount and GetAllFormats) and knows how to render itself in any of them (see GetDataHere). It can also receive its value from the outside in a format it supports if it implements the SetData method. Please see the documentation of this class for more details.
-
-Both clipboard and drag and drop operations have two sides: the source and target, the data provider and the data receiver. These which may be in the same application and even the same window when, for example, you drag some text from one position to another in a word processor. Let us describe what each of them should do.
-
-"""

wxPython/demo/FileBrowseButton.py

@@ -1,47 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib.filebrowsebutton import FileBrowseButton, FileBrowseButtonWithHistory
-
-
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, ID, log):
-        wxPanel.__init__(self, parent, ID)
-        self.log = log
-        self.fbb = FileBrowseButton(self, -1, wxPoint(20,20), wxSize(450, -1),
-                                    changeCallback = self.fbbCallback)
-        self.fbbh = FileBrowseButtonWithHistory(self, -1, wxPoint(20, 50),
-                                                wxSize(450, -1),
-                                                #changeCallback = self.fbbhCallback
-                                                )
-
-        self.fbbh.SetHistory(['You', 'can', 'put', 'some', 'file', 'names', 'here'])
-
-
-    def fbbCallback(self, evt):
-        self.log.write('FileBrowseButton: %s\n' % evt.GetString())
-
-
-    def fbbhCallback(self, evt):
-        if hasattr(self, 'fbbh'):
-            value = evt.GetString()
-            self.log.write('FileBrowseButtonWithHistory: %s\n' % value)
-            history = self.fbbh.GetHistory()
-            history.append(value)
-            self.fbbh.SetHistory(history)
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, -1, log)
-    return win
-
-
-
-#----------------------------------------------------------------------
-
-
-
-overview = FileBrowseButton.__doc__

wxPython/demo/FontEnumerator.py

@@ -1,61 +0,0 @@
-
-from wxPython.wx import *
-
-#----------------------------------------------------------------------
-
-## class MyFontEnumerator(wxFontEnumerator):
-##     def __init__(self, list):
-##         wxFontEnumerator.__init__(self)
-##         self.list = list
-
-##     def OnFacename(self, face):
-##         self.list.append(face)
-##         return true
-
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-##         list = []
-##         e = MyFontEnumerator(list)
-##         e.EnumerateFacenames()
-
-        e = wxFontEnumerator()
-        e.EnumerateFacenames()
-        list = e.GetFacenames()
-
-        list.sort()
-
-        wxStaticText(self, -1, "Face names:", wxPoint(15, 50), wxSize(65, 18))
-        self.lb1 = wxListBox(self, 60, wxPoint(80, 50), wxSize(200, 250),
-                             list, wxLB_SINGLE)
-        self.lb1.SetSelection(0)
-
-
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-#----------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-overview = """\
-wxFontEnumerator enumerates either all available fonts on the system or only the ones with given attributes - either only fixed-width (suited for use in programs such as terminal emulators and the like) or the fonts available in the given encoding.
-
-"""

wxPython/demo/GenericButtons.py

@@ -1,93 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib.buttons import wxGenButton, wxGenBitmapButton, \
-                                 wxGenToggleButton, wxGenBitmapToggleButton
-
-#----------------------------------------------------------------------
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        b = wxButton(self, -1, "A real button", (10,10))
-        b.SetDefault()
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b = wxButton(self, -1, "non-default", (140, 10))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        #wxTextCtrl(self, -1, "", (10,40))
-
-        b = wxGenButton(self, -1, 'Hello', (10,65))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b = wxGenButton(self, -1, 'disabled', (140,65))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b.Enable(false)
-
-        b = wxGenButton(self, -1, 'bigger', (250,50))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b.SetFont(wxFont(20, wxSWISS, wxNORMAL, wxBOLD, false))
-        b.SetBezelWidth(5)
-        b.SetBestSize()
-        b.SetBackgroundColour(wxNamedColour("Navy"))
-        b.SetForegroundColour(wxWHITE)
-        #b.SetUseFocusIndicator(false)
-        b.SetToolTipString("This is a BIG button...")
-
-        bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP)
-        b = wxGenBitmapButton(self, -1, bmp, (10, 130))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-
-
-        b = wxGenBitmapButton(self, -1, None, (140, 130))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        bmp = wxBitmap('bitmaps/lb1.bmp', wxBITMAP_TYPE_BMP)
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapLabel(bmp)
-        bmp = wxBitmap('bitmaps/lb2.bmp', wxBITMAP_TYPE_BMP)
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapSelected(bmp)
-        b.SetBestSize()
-
-        b = wxGenToggleButton(self, -1, "Toggle Button", (10, 230))
-        EVT_BUTTON(self, b.GetId(), self.OnToggleButton)
-
-
-        b = wxGenBitmapToggleButton(self, -1, None, (140, 230))
-        EVT_BUTTON(self, b.GetId(), self.OnToggleButton)
-        bmp = wxBitmap('bitmaps/lb1.bmp', wxBITMAP_TYPE_BMP)
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapLabel(bmp)
-        bmp = wxBitmap('bitmaps/lb2.bmp', wxBITMAP_TYPE_BMP)
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapSelected(bmp)
-        b.SetToggle(true)
-        b.SetBestSize()
-
-
-    def OnButton(self, event):
-        self.log.WriteText("Button Clicked: %d\n" % event.GetId())
-
-    def OnToggleButton(self, event):
-        msg = (event.GetIsDown() and "on") or "off"
-        self.log.WriteText("Button %d Toggled: %s\n" % (event.GetId(), msg))
-
-
-
-#----------------------------------------------------------------------
-
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-
-#----------------------------------------------------------------------
-
-
-import wxPython.lib.buttons
-overview = wxPython.lib.buttons.__doc__

wxPython/demo/GridCustEditor.py

@@ -1,231 +0,0 @@
-#!/usr/bin/env python
-
-from wxPython.wx import *
-from wxPython.grid import *
-
-#---------------------------------------------------------------------------
-class MyCellEditor(wxPyGridCellEditor):
-    """
-    This is a sample GridCellEditor that shows you how to make your own custom
-    grid editors.  All the methods that can be overridden are show here.  The
-    ones that must be overridden are marked with "*Must Override*" in the
-    docstring.
-
-    Notice that in order to call the base class version of these special
-    methods we use the method name preceded by "base_".  This is because these
-    methods are "virtual" in C++ so if we try to call wxGridCellEditor.Create
-    for example, then when the wxPython extension module tries to call
-    ptr->Create(...) then it actually calls the derived class version which
-    looks up the method in this class and calls it, causing a recursion loop.
-    If you don't understand any of this, don't worry, just call the "base_"
-    version instead.
-    """
-    def __init__(self, log):
-        self.log = log
-        self.log.write("MyCellEditor ctor\n")
-        wxPyGridCellEditor.__init__(self)
-
-
-    def Create(self, parent, id, evtHandler):
-        """
-        Called to create the control, which must derive from wxControl.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: Create\n")
-        self._tc = wxTextCtrl(parent, id, "")
-        self._tc.SetInsertionPoint(0)
-        self.SetControl(self._tc)
-        if evtHandler:
-            self._tc.PushEventHandler(evtHandler)
-
-
-    def SetSize(self, rect):
-        """
-        Called to position/size the edit control within the cell rectangle.
-        If you don't fill the cell (the rect) then be sure to override
-        PaintBackground and do something meaningful there.
-        """
-        self.log.write("MyCellEditor: SetSize %s\n" % rect)
-        self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2)
-
-
-    def Show(self, show, attr):
-        """
-        Show or hide the edit control.  You can use the attr (if not None)
-        to set colours or fonts for the control.
-        """
-        self.log.write("MyCellEditor: Show(self, %s, %s)\n" % (show, attr))
-        self.base_Show(show, attr)
-
-
-    def PaintBackground(self, rect, attr):
-        """
-        Draws the part of the cell not occupied by the edit control.  The
-        base  class version just fills it with background colour from the
-        attribute.  In this class the edit control fills the whole cell so
-        don't do anything at all in order to reduce flicker.
-        """
-        self.log.write("MyCellEditor: PaintBackground\n")
-
-
-    def BeginEdit(self, row, col, grid):
-        """
-        Fetch the value from the table and prepare the edit control
-        to begin editing.  Set the focus to the edit control.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: BeginEdit (%d,%d)\n" % (row, col))
-        self.startValue = grid.GetTable().GetValue(row, col)
-        self._tc.SetValue(self.startValue)
-        self._tc.SetInsertionPointEnd()
-        self._tc.SetFocus()
-
-        # For this example, select the text
-        self._tc.SetSelection(0, self._tc.GetLastPosition())
-
-
-    def EndEdit(self, row, col, grid):
-        """
-        Complete the editing of the current cell. Returns true if the value
-        has changed.  If necessary, the control may be destroyed.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: EndEdit (%d,%d)\n" % (row, col))
-        changed = false
-
-        val = self._tc.GetValue()
-        if val != self.startValue:
-            changed = true
-            grid.GetTable().SetValue(row, col, val) # update the table
-
-        self.startValue = ''
-        self._tc.SetValue('')
-        return changed
-
-
-    def Reset(self):
-        """
-        Reset the value in the control back to its starting value.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: Reset\n")
-        self._tc.SetValue(self.startValue)
-        self._tc.SetInsertionPointEnd()
-
-
-    def IsAcceptedKey(self, evt):
-        """
-        Return TRUE to allow the given key to start editing: the base class
-        version only checks that the event has no modifiers.  F2 is special
-        and will always start the editor.
-        """
-        self.log.write("MyCellEditor: IsAcceptedKey: %d\n" % (evt.GetKeyCode()))
-
-        ## Oops, there's a bug here, we'll have to do it ourself..
-        ##return self.base_IsAcceptedKey(evt)
-
-        return (not (evt.ControlDown() or evt.AltDown()) and
-                evt.GetKeyCode() != WXK_SHIFT)
-
-
-    def StartingKey(self, evt):
-        """
-        If the editor is enabled by pressing keys on the grid, this will be
-        called to let the editor do something about that first key if desired.
-        """
-        self.log.write("MyCellEditor: StartingKey %d\n" % evt.GetKeyCode())
-        key = evt.GetKeyCode()
-        ch = None
-        if key in [WXK_NUMPAD0, WXK_NUMPAD1, WXK_NUMPAD2, WXK_NUMPAD3, WXK_NUMPAD4,
-                   WXK_NUMPAD5, WXK_NUMPAD6, WXK_NUMPAD7, WXK_NUMPAD8, WXK_NUMPAD9]:
-            ch = ch = chr(ord('0') + key - WXK_NUMPAD0)
-
-        elif key < 256 and key >= 0 and chr(key) in string.printable:
-            ch = chr(key)
-            if not evt.ShiftDown():
-                ch = string.lower(ch)
-
-        if ch is not None:
-            # For this example, replace the text.  Normally we would append it.
-            #self._tc.AppendText(ch)
-            self._tc.SetValue(ch)
-        else:
-            evt.Skip()
-
-
-    def StartingClick(self):
-        """
-        If the editor is enabled by clicking on the cell, this method will be
-        called to allow the editor to simulate the click on the control if
-        needed.
-        """
-        self.log.write("MyCellEditor: StartingClick\n")
-
-
-    def Destroy(self):
-        """final cleanup"""
-        self.log.write("MyCellEditor: Destroy\n")
-        self.base_Destroy()
-
-
-    def Clone(self):
-        """
-        Create a new object which is the copy of this one
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: Clone\n")
-        return MyCellEditor(self.log)
-
-
-#---------------------------------------------------------------------------
-class GridEditorTest(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        self.log = log
-
-        self.CreateGrid(10, 3)
-
-        # Somebody changed the grid so the type registry takes precedence
-        # over the default attribute set for editors and renderers, so we
-        # have to set null handlers for the type registry before the
-        # default editor will get used otherwise...
-        #self.RegisterDataType(wxGRID_VALUE_STRING, None, None)
-        #self.SetDefaultEditor(MyCellEditor(self.log))
-
-        # Or we could just do it like this:
-        #self.RegisterDataType(wxGRID_VALUE_STRING,
-        #                      wxGridCellStringRenderer(),
-        #                      MyCellEditor(self.log))
-
-        # but for this example, we'll just set the custom editor on one cell
-        self.SetCellEditor(1, 0, MyCellEditor(self.log))
-        self.SetCellValue(1, 0, "Try to edit this box")
-
-        # and on a column
-        attr = wxGridCellAttr()
-        attr.SetEditor(MyCellEditor(self.log))
-        self.SetColAttr(2, attr)
-        self.SetCellValue(1, 2, "or any in this column")
-
-        self.SetColSize(0, 150)
-        self.SetColSize(1, 150)
-        self.SetColSize(2, 150)
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Custom Grid Cell Editor Test",
-                         size=(640,480))
-        grid = GridEditorTest(self, log)
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-

wxPython/demo/GridCustTable.py

@@ -1,153 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-import string
-
-#---------------------------------------------------------------------------
-
-class CustomDataTable(wxPyGridTableBase):
-    """
-    """
-
-    def __init__(self, log):
-        wxPyGridTableBase.__init__(self)
-        self.log = log
-
-        self.colLabels = ['ID', 'Description', 'Severity', 'Priority', 'Platform',
-                          'Opened?', 'Fixed?', 'Tested?']
-
-        self.dataTypes = [wxGRID_VALUE_NUMBER,
-                          wxGRID_VALUE_STRING,
-                          wxGRID_VALUE_CHOICE + ':only in a million years!,wish list,minor,normal,major,critical',
-                          wxGRID_VALUE_NUMBER + ':1,5',
-                          wxGRID_VALUE_CHOICE + ':all,MSW,GTK,other',
-                          wxGRID_VALUE_BOOL,
-                          wxGRID_VALUE_BOOL,
-                          wxGRID_VALUE_BOOL]
-
-        self.data = [
-            [1010, "The foo doesn't bar", "major", 1, 'MSW', 1, 1, 1],
-            [1011, "I've got a wicket in my wocket", "wish list", 2, 'other', 0, 0, 0],
-            [1012, "Rectangle() returns a triangle", "critical", 5, 'all', 0, 0, 0]
-
-            ]
-
-
-    #--------------------------------------------------
-    # required methods for the wxPyGridTableBase interface
-
-    def GetNumberRows(self):
-        return len(self.data) + 1
-
-    def GetNumberCols(self):
-        return len(self.data[0])
-
-    def IsEmptyCell(self, row, col):
-        return not self.data[row][col]
-
-    # Get/Set values in the table.  The Python version of these
-    # methods can handle any data-type, (as long as the Editor and
-    # Renderer understands the type too,) not just strings as in the
-    # C++ version.
-    def GetValue(self, row, col):
-        try:
-            return self.data[row][col]
-        except IndexError:
-            return ''
-
-    def SetValue(self, row, col, value):
-        try:
-            self.data[row][col] = value
-        except IndexError:
-            # add a new row
-            self.data.append([''] * self.GetNumberCols())
-            self.SetValue(row, col, value)
-
-            # tell the grid we've added a row
-            msg = wxGridTableMessage(self,                             # The table
-                                     wxGRIDTABLE_NOTIFY_ROWS_APPENDED, # what we did to it
-                                     1)                                # how many
-
-            self.GetView().ProcessTableMessage(msg)
-
-
-    #--------------------------------------------------
-    # Some optional methods
-
-    # Called when the grid needs to display labels
-    def GetColLabelValue(self, col):
-        return self.colLabels[col]
-
-    # Called to determine the kind of editor/renderer to use by
-    # default, doesn't necessarily have to be the same type used
-    # nativly by the editor/renderer if they know how to convert.
-    def GetTypeName(self, row, col):
-        return self.dataTypes[col]
-
-    # Called to determine how the data can be fetched and stored by the
-    # editor and renderer.  This allows you to enforce some type-safety
-    # in the grid.
-    def CanGetValueAs(self, row, col, typeName):
-        colType = string.split(self.dataTypes[col], ':')[0]
-        if typeName == colType:
-            return true
-        else:
-            return false
-
-    def CanSetValueAs(self, row, col, typeName):
-        return self.CanGetValueAs(row, col, typeName)
-
-
-
-
-
-#---------------------------------------------------------------------------
-
-
-
-class CustTableGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-
-        table = CustomDataTable(log)
-
-        # The second parameter means that the grid is to take ownership of the
-        # table and will destroy it when done.  Otherwise you would need to keep
-        # a reference to it and call it's Destroy method later.
-        self.SetTable(table, true)
-
-        self.SetRowLabelSize(0)
-        self.SetMargins(0,0)
-        self.AutoSizeColumns(false)
-
-        EVT_GRID_CELL_LEFT_DCLICK(self, self.OnLeftDClick)
-
-
-
-    # I do this because I don't like the default behaviour of not starting the
-    # cell editor on double clicks, but only a second click.
-    def OnLeftDClick(self, evt):
-        if self.CanEnableCellControl():
-            self.EnableCellEditControl()
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Custom Table, data driven Grid  Demo", size=(640,480))
-        grid = CustTableGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/GridEnterHandler.py

@@ -1,62 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-#---------------------------------------------------------------------------
-
-class NewEnterHandlingGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        self.log = log
-
-        self.CreateGrid(20, 6)
-
-        self.SetCellValue(0, 0, "Enter moves to the right")
-        self.SetCellValue(0, 5, "Enter wraps to next row")
-        self.SetColSize(0, 150)
-        self.SetColSize(5, 150)
-
-        EVT_KEY_DOWN(self, self.OnKeyDown)
-
-
-    def OnKeyDown(self, evt):
-        if evt.KeyCode() != WXK_RETURN:
-            evt.Skip()
-            return
-
-        if evt.ControlDown():   # the edit control needs this key
-            evt.Skip()
-            return
-
-        self.DisableCellEditControl()
-        success = self.MoveCursorRight(evt.ShiftDown())
-        if not success:
-            newRow = self.GetGridCursorRow() + 1
-            if newRow < self.GetTable().GetNumberRows():
-                self.SetGridCursor(newRow, 0)
-                self.MakeCellVisible(newRow, 0)
-            else:
-                # this would be a good place to add a new row if your app
-                # needs to do that
-                pass
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
-        grid = NewEnterHandlingGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/GridHugeTable.py

@@ -1,71 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-#---------------------------------------------------------------------------
-
-class HugeTable(wxPyGridTableBase):
-
-    """
-    This is all it takes to make a custom data table to plug into a
-    wxGrid.  There are many more methods that can be overridden, but
-    the ones shown below are the required ones.  This table simply
-    provides strings containing the row and column values.
-    """
-
-    def __init__(self, log):
-        wxPyGridTableBase.__init__(self)
-        self.log = log
-
-    def GetNumberRows(self):
-        return 10000
-
-    def GetNumberCols(self):
-        return 10000
-
-    def IsEmptyCell(self, row, col):
-        return false
-
-    def GetValue(self, row, col):
-        return str( (row, col) )
-
-    def SetValue(self, row, col, value):
-        self.log.write('SetValue(%d, %d, "%s") ignored.\n' % (row, col, value))
-
-
-#---------------------------------------------------------------------------
-
-
-
-class HugeTableGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-
-        table = HugeTable(log)
-
-        # The second parameter means that the grid is to take ownership of the
-        # table and will destroy it when done.  Otherwise you would need to keep
-        # a reference to it and call it's Destroy method later.
-        self.SetTable(table, true)
-
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Huge (virtual) Table Demo", size=(640,480))
-        grid = HugeTableGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/GridSimple.py

@@ -1,189 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-#---------------------------------------------------------------------------
-
-class SimpleGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        self.log = log
-        self.moveTo = None
-
-        EVT_IDLE(self, self.OnIdle)
-
-        self.CreateGrid(25, 25)
-
-        # simple cell formatting
-        self.SetColSize(3, 200)
-        self.SetRowSize(4, 45)
-        self.SetCellValue(0, 0, "First cell")
-        self.SetCellValue(1, 1, "Another cell")
-        self.SetCellValue(2, 2, "Yet another cell")
-        self.SetCellFont(0, 0, wxFont(12, wxROMAN, wxITALIC, wxNORMAL))
-        self.SetCellTextColour(1, 1, wxRED)
-        self.SetCellBackgroundColour(2, 2, wxCYAN)
-
-        # attribute objects let you keep a set of formatting values
-        # in one spot, and reuse them if needed
-        attr = wxGridCellAttr()
-        attr.SetTextColour(wxBLACK)
-        attr.SetBackgroundColour(wxRED)
-        attr.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD))
-
-        # you can set cell attributes for the whole row (or column)
-        self.SetRowAttr(5, attr)
-
-        self.SetColLabelValue(0, "Custom")
-        self.SetColLabelValue(1, "column")
-        self.SetColLabelValue(2, "labels")
-
-        # test all the events
-        EVT_GRID_CELL_LEFT_CLICK(self, self.OnCellLeftClick)
-        EVT_GRID_CELL_RIGHT_CLICK(self, self.OnCellRightClick)
-        EVT_GRID_CELL_LEFT_DCLICK(self, self.OnCellLeftDClick)
-        EVT_GRID_CELL_RIGHT_DCLICK(self, self.OnCellRightDClick)
-
-        EVT_GRID_LABEL_LEFT_CLICK(self, self.OnLabelLeftClick)
-        EVT_GRID_LABEL_RIGHT_CLICK(self, self.OnLabelRightClick)
-        EVT_GRID_LABEL_LEFT_DCLICK(self, self.OnLabelLeftDClick)
-        EVT_GRID_LABEL_RIGHT_DCLICK(self, self.OnLabelRightDClick)
-
-        EVT_GRID_ROW_SIZE(self, self.OnRowSize)
-        EVT_GRID_COL_SIZE(self, self.OnColSize)
-
-        EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
-        EVT_GRID_CELL_CHANGE(self, self.OnCellChange)
-        EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
-
-        EVT_GRID_EDITOR_SHOWN(self, self.OnEditorShown)
-        EVT_GRID_EDITOR_HIDDEN(self, self.OnEditorHidden)
-
-
-    def OnCellLeftClick(self, evt):
-        self.log.write("OnCellLeftClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnCellRightClick(self, evt):
-        self.log.write("OnCellRightClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnCellLeftDClick(self, evt):
-        self.log.write("OnCellLeftDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnCellRightDClick(self, evt):
-        self.log.write("OnCellRightDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelLeftClick(self, evt):
-        self.log.write("OnLabelLeftClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelRightClick(self, evt):
-        self.log.write("OnLabelRightClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelLeftDClick(self, evt):
-        self.log.write("OnLabelLeftDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelRightDClick(self, evt):
-        self.log.write("OnLabelRightDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-
-    def OnRowSize(self, evt):
-        self.log.write("OnRowSize: row %d, %s\n" %
-                       (evt.GetRowOrCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnColSize(self, evt):
-        self.log.write("OnColSize: col %d, %s\n" %
-                       (evt.GetRowOrCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnRangeSelect(self, evt):
-        if evt.Selecting():
-            self.log.write("OnRangeSelect: top-left %s, bottom-right %s\n" %
-                           (evt.GetTopLeftCoords(), evt.GetBottomRightCoords()))
-        evt.Skip()
-
-
-    def OnCellChange(self, evt):
-        self.log.write("OnCellChange: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-
-        # Show how to stay in a cell that has bad data.  We can't just
-        # call SetGridCursor here since we are nested inside one so it
-        # won't have any effect.  Instead, set coordinants to move to in
-        # idle time.
-        value = self.GetCellValue(evt.GetRow(), evt.GetCol())
-        if value == 'no good':
-            self.moveTo = evt.GetRow(), evt.GetCol()
-
-    def OnIdle(self, evt):
-        if self.moveTo != None:
-            self.SetGridCursor(self.moveTo[0], self.moveTo[1])
-            self.moveTo = None
-
-
-
-    def OnSelectCell(self, evt):
-        self.log.write("OnSelectCell: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-
-        # Another way to stay in a cell that has a bad value...
-        row = self.GetGridCursorRow()
-        col = self.GetGridCursorCol()
-        if self.IsCellEditControlEnabled():
-            self.HideCellEditControl()
-            self.DisableCellEditControl()
-        value = self.GetCellValue(row, col)
-        if value == 'no good 2':
-            return  # cancels the cell selection
-        else:
-            evt.Skip()
-
-
-
-    def OnEditorShown(self, evt):
-        self.log.write("OnEditorShown: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnEditorHidden(self, evt):
-        self.log.write("OnEditorHidden: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
-        grid = SimpleGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------
-
-

wxPython/demo/GridStdEdRend.py

@@ -1,181 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-import string, random
-
-#---------------------------------------------------------------------------
-
-class MyCustomRenderer(wxPyGridCellRenderer):
-    def __init__(self):
-        wxPyGridCellRenderer.__init__(self)
-
-    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
-        dc.SetBackgroundMode(wxSOLID)
-        dc.SetBrush(wxBrush(wxBLACK, wxSOLID))
-        dc.SetPen(wxTRANSPARENT_PEN)
-        dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
-
-        dc.SetBackgroundMode(wxTRANSPARENT)
-        dc.SetFont(attr.GetFont())
-
-        text = grid.GetCellValue(row, col)
-        colors = [wxRED, wxWHITE, wxCYAN]
-        x = rect.x + 1
-        y = rect.y + 1
-        for ch in text:
-            dc.SetTextForeground(random.choice(colors))
-            dc.DrawText(ch, x, y)
-            w, h = dc.GetTextExtent(ch)
-            x = x + w
-            if x > rect.right - 5:
-                break
-
-
-    def GetBestSize(self, grid, attr, dc, row, col):
-        text = grid.GetCellValue(row, col)
-        dc.SetFont(attr.GetFont())
-        w, h = dc.GetTextExtent(text)
-        return wxSize(w, h)
-
-
-    def Clone(self):
-        return MyCustomRenderer()
-
-
-#---------------------------------------------------------------------------
-
-rendererDemoData = [
-    ('wxGridCellStringRenderer\n(the default)', 'this is a text value', wxGridCellStringRenderer, ()),
-    ('wxGridCellNumberRenderer', '12345', wxGridCellNumberRenderer, ()),
-    ('wxGridCellFloatRenderer', '1234.5678', wxGridCellFloatRenderer, (6,2)),
-    ('wxGridCellBoolRenderer', '1', wxGridCellBoolRenderer, ()),
-    ('MyCustomRenderer', 'This is my renderer', MyCustomRenderer, ()),
-    ]
-
-editorDemoData = [
-    ('wxGridCellTextEditor\n(the default)', 'Here is some more text', wxGridCellTextEditor, ()),
-    ('wxGridCellNumberEditor\nwith min,max', '101', wxGridCellNumberEditor, (5, 10005)),
-    ('wxGridCellNumberEditor\nwithout bounds', '101', wxGridCellNumberEditor, ()),
-    ('wxGridCellFloatEditor', '1234.5678', wxGridCellFloatEditor, ()),
-    ('wxGridCellBoolEditor', '1', wxGridCellBoolEditor, ()),
-    ('wxGridCellChoiceEditor', 'one', wxGridCellChoiceEditor, (['one', 'two', 'three', 'four',
-                                                         'kick', 'Microsoft', 'out the',
-                                                         'door'], false)),
-    ]
-
-
-comboDemoData = [
-    ('wxGridCellNumberRenderer\nwxGridCellNumberEditor', '20792', wxGridCellNumberRenderer, wxGridCellNumberEditor),
-    ('wxGridCellBoolRenderer\nwxGridCellBoolEditor', '1', wxGridCellBoolRenderer, wxGridCellBoolEditor),
-    ]
-
-
-class EditorsAndRenderersGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        self.log = log
-
-        self.CreateGrid(25, 8)
-        renCol = 1
-        edCol = 4
-
-
-        self.SetCellValue(0, renCol, '''\
-Cell Renderers are used to draw
-the contents of the cell when they
-need to be refreshed.  Different
-types of Renderers can be plugged in
-to different cells in the grid, it can
-even be automatically determined based
-on the type of data in the cell.
-''')
-
-        self.SetCellValue(0, edCol, '''\
-Cell Editors are used when the
-value of the cell is edited by
-the user.  An editor class is
-wrapped around a an object
-derived from wxControl and it
-implements some methods required
-to integrate with the grid.
-''')
-
-        self.SetCellValue(16, renCol, '''\
-Here are some combinations of Editors and
-Renderers used together.
-''')
-
-        row = 2
-        for label, value, renderClass, args in rendererDemoData:
-            renderer = apply(renderClass, args)
-            self.SetCellValue(row, renCol, label)
-            self.SetCellValue(row, renCol+1, value)
-            self.SetCellRenderer(row, renCol+1, renderer)
-            row = row + 2
-
-
-        row = 2
-        for label, value, editorClass, args in editorDemoData:
-            editor = apply(editorClass, args)
-            self.SetCellValue(row, edCol, label)
-            self.SetCellValue(row, edCol+1, value)
-            self.SetCellEditor(row, edCol+1, editor)
-            row = row + 2
-
-
-        row = 18
-        for label, value, renClass, edClass in comboDemoData:
-            self.SetCellValue(row, renCol, label)
-            self.SetCellValue(row, renCol+1, value)
-            editor = apply(edClass, ()) #args)
-            renderer = apply(renClass, ()) #args)
-            self.SetCellEditor(row, renCol+1, editor)
-            self.SetCellRenderer(row, renCol+1, renderer)
-            row = row + 2
-
-
-        font = self.GetFont()
-        font.SetWeight(wxBOLD)
-        attr = wxGridCellAttr()
-        attr.SetFont(font)
-        attr.SetBackgroundColour(wxLIGHT_GREY)
-        attr.SetReadOnly(true)
-        attr.SetAlignment(wxRIGHT, -1)
-        self.SetColAttr(renCol, attr)
-        self.SetColAttr(edCol, attr)
-
-        # There is a bug in wxGTK for this method...
-        if wxPlatform != '__WXGTK__':
-            self.AutoSizeColumns(true)
-        self.AutoSizeRows(true)
-
-        EVT_GRID_CELL_LEFT_DCLICK(self, self.OnLeftDClick)
-
-
-    # I do this because I don't like the default behaviour of not starting the
-    # cell editor on double clicks, but only a second click.
-    def OnLeftDClick(self, evt):
-        if self.CanEnableCellControl():
-            self.EnableCellEditControl()
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Editors and Renderers Demo", size=(640,480))
-        grid = EditorsAndRenderersGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/Layoutf.py

@@ -1,62 +0,0 @@
-
-from wxPython.wx          import *
-from wxPython.lib.layoutf import Layoutf
-
-#---------------------------------------------------------------------------
-
-class TestLayoutf(wxPanel):
-    def __init__(self, parent):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetAutoLayout(true)
-        EVT_BUTTON(self, 100, self.OnButton)
-
-        self.panelA = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelA.SetBackgroundColour(wxBLUE)
-        self.panelA.SetConstraints(Layoutf('t=t10#1;l=l10#1;b=b10#1;r%r50#1',(self,)))
-
-        self.panelB = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelB.SetBackgroundColour(wxRED)
-        self.panelB.SetConstraints(Layoutf('t=t10#1;r=r10#1;b%b30#1;l>10#2', (self,self.panelA)))
-
-        self.panelC = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelC.SetBackgroundColour(wxWHITE)
-        self.panelC.SetConstraints(Layoutf('t_10#3;r=r10#1;b=b10#1;l>10#2', (self,self.panelA,self.panelB)))
-
-        b = wxButton(self.panelA, 100, ' Panel A ')
-        b.SetConstraints(Layoutf('X=X#1;Y=Y#1;h*;w%w50#1', (self.panelA,)))
-
-        b = wxButton(self.panelB, 100, ' Panel B ')
-        b.SetConstraints(Layoutf('t=t2#1;r=r4#1;h*;w*', (self.panelB,)))
-
-        self.panelD = wxWindow(self.panelC, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelD.SetBackgroundColour(wxGREEN)
-        self.panelD.SetConstraints(Layoutf('b%h50#1;r%w50#1;h=h#2;w=w#2', (self.panelC, b)))
-
-        b = wxButton(self.panelC, 100, ' Panel C ')
-        b.SetConstraints(Layoutf('t_#1;l>#1;h*;w*', (self.panelD,)))
-
-        wxStaticText(self.panelD, -1, "Panel D", wxPoint(4, 4)).SetBackgroundColour(wxGREEN)
-
-    def OnButton(self, event):
-        wxBell()
-
-
-
-#---------------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestLayoutf(nb)
-    return win
-
-#---------------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-overview = Layoutf.__doc__

wxPython/demo/MDIDemo.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python
-
-from wxPython.wx import *
-from wxScrolledWindow import MyCanvas
-
-#----------------------------------------------------------------------
-
-class MyParentFrame(wxMDIParentFrame):
-    def __init__(self):
-        wxMDIParentFrame.__init__(self, None, -1, "MDI Parent", size=(600,400))
-
-        self.winCount = 0
-        menu = wxMenu()
-        menu.Append(5000, "&New Window")
-        menu.AppendSeparator()
-        menu.Append(5001, "E&xit")
-
-        menubar = wxMenuBar()
-        menubar.Append(menu, "&File")
-        self.SetMenuBar(menubar)
-
-        self.CreateStatusBar()
-
-        EVT_MENU(self, 5000, self.OnNewWindow)
-        EVT_MENU(self, 5001, self.OnExit)
-
-
-    def OnExit(self, evt):
-        self.Close(true)
-
-
-    def OnNewWindow(self, evt):
-        self.winCount = self.winCount + 1
-        win = wxMDIChildFrame(self, -1, "Child Window: %d" % self.winCount)
-        canvas = MyCanvas(win)
-        win.Show(true)
-
-
-#----------------------------------------------------------------------
-
-class MyApp(wxApp):
-    def OnInit(self):
-        frame = MyParentFrame()
-        frame.Show(true)
-        self.SetTopWindow(frame)
-        return true
-
-
-app = MyApp(0)
-app.MainLoop()
-
-
-

wxPython/demo/MDISashDemo.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python
-
-from wxPython.wx import *
-from wxScrolledWindow import MyCanvas
-
-#----------------------------------------------------------------------
-
-class MyParentFrame(wxMDIParentFrame):
-    ID_WINDOW_TOP    = 5100
-    ID_WINDOW_LEFT1  = 5101
-    ID_WINDOW_LEFT2  = 5102
-    ID_WINDOW_BOTTOM = 5103
-
-    def __init__(self):
-        wxMDIParentFrame.__init__(self, None, -1, "MDI Parent", size=(600,400),
-                                  style = wxDEFAULT_FRAME_STYLE | wxHSCROLL | wxVSCROLL)
-
-        self.winCount = 0
-        menu = wxMenu()
-        menu.Append(5000, "&New Window")
-        menu.AppendSeparator()
-        menu.Append(5001, "E&xit")
-
-        menubar = wxMenuBar()
-        menubar.Append(menu, "&File")
-        self.SetMenuBar(menubar)
-
-        #self.CreateStatusBar()
-
-        EVT_MENU(self, 5000, self.OnNewWindow)
-        EVT_MENU(self, 5001, self.OnExit)
-
-
-        EVT_SASH_DRAGGED_RANGE(self,
-                               self.ID_WINDOW_TOP, self.ID_WINDOW_BOTTOM,
-                               self.OnSashDrag)
-        EVT_SIZE(self, self.OnSize)
-
-
-        # Create some layout windows
-        # A window like a toolbar
-        win = wxSashLayoutWindow(self, self.ID_WINDOW_TOP, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((1000, 30))
-        win.SetOrientation(wxLAYOUT_HORIZONTAL)
-        win.SetAlignment(wxLAYOUT_TOP)
-        win.SetBackgroundColour(wxColour(255, 0, 0))
-        win.SetSashVisible(wxSASH_BOTTOM, true)
-
-        self.topWindow = win
-
-
-        # A window like a statusbar
-        win = wxSashLayoutWindow(self, self.ID_WINDOW_BOTTOM, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((1000, 30))
-        win.SetOrientation(wxLAYOUT_HORIZONTAL)
-        win.SetAlignment(wxLAYOUT_BOTTOM)
-        win.SetBackgroundColour(wxColour(0, 0, 255))
-        win.SetSashVisible(wxSASH_TOP, true)
-
-        self.bottomWindow = win
-
-
-        # A window to the left of the client window
-        win =  wxSashLayoutWindow(self, self.ID_WINDOW_LEFT1, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((120, 1000))
-        win.SetOrientation(wxLAYOUT_VERTICAL)
-        win.SetAlignment(wxLAYOUT_LEFT)
-        win.SetBackgroundColour(wxColour(0, 255, 0))
-        win.SetSashVisible(wxSASH_RIGHT, TRUE)
-        win.SetExtraBorderSize(10)
-        textWindow = wxTextCtrl(win, -1, "", wxDefaultPosition, wxDefaultSize,
-                                wxTE_MULTILINE|wxSUNKEN_BORDER)
-        textWindow.SetValue("A sub window")
-
-        self.leftWindow1 = win
-
-
-        # Another window to the left of the client window
-        win = wxSashLayoutWindow(self, self.ID_WINDOW_LEFT2, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((120, 1000))
-        win.SetOrientation(wxLAYOUT_VERTICAL)
-        win.SetAlignment(wxLAYOUT_LEFT)
-        win.SetBackgroundColour(wxColour(0, 255, 255))
-        win.SetSashVisible(wxSASH_RIGHT, TRUE)
-
-        self.leftWindow2 = win
-
-
-    def OnSashDrag(self, event):
-        if event.GetDragStatus() == wxSASH_STATUS_OUT_OF_RANGE:
-            return
-
-        eID = event.GetId()
-        if eID == self.ID_WINDOW_TOP:
-            self.topWindow.SetDefaultSize(wxSize(1000, event.GetDragRect().height))
-
-        elif eID == self.ID_WINDOW_LEFT1:
-            self.leftWindow1.SetDefaultSize(wxSize(event.GetDragRect().width, 1000))
-
-
-        elif eID == self.ID_WINDOW_LEFT2:
-            self.leftWindow2.SetDefaultSize(wxSize(event.GetDragRect().width, 1000))
-
-        elif eID == self.ID_WINDOW_BOTTOM:
-            self.bottomWindow.SetDefaultSize(wxSize(1000, event.GetDragRect().height))
-
-        wxLayoutAlgorithm().LayoutMDIFrame(self)
-        self.GetClientWindow().Refresh()
-
-
-    def OnSize(self, event):
-        wxLayoutAlgorithm().LayoutMDIFrame(self)
-
-
-    def OnExit(self, evt):
-        self.Close(true)
-
-
-    def OnNewWindow(self, evt):
-        self.winCount = self.winCount + 1
-        win = wxMDIChildFrame(self, -1, "Child Window: %d" % self.winCount)
-        canvas = MyCanvas(win)
-        win.Show(true)
-
-
-#----------------------------------------------------------------------
-
-class MyApp(wxApp):
-    def OnInit(self):
-        frame = MyParentFrame()
-        frame.Show(true)
-        self.SetTopWindow(frame)
-        return true
-
-
-app = MyApp(0)
-app.MainLoop()
-
-
-

wxPython/demo/Main.py

@@ -1,544 +0,0 @@
-#!/bin/env python
-#----------------------------------------------------------------------------
-# Name:         Main.py
-# Purpose:      Testing lots of stuff, controls, window types, etc.
-#
-# Author:       Robin Dunn
-#
-# Created:      A long time ago, in a galaxy far, far away...
-# RCS-ID:       $Id$
-# Copyright:    (c) 1999 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-import sys, os
-from   wxPython.wx import *
-from   wxPython.lib.splashscreen import SplashScreen
-from   wxPython.html import wxHtmlWindow
-
-#---------------------------------------------------------------------------
-
-
-_treeList = [
-    ('New since last release', ['wxProcess',
-                                ]),
-
-    ('Managed Windows', ['wxFrame', 'wxDialog', 'wxMiniFrame']),
-
-    ('Non-Managed Windows', ['wxGrid', 'wxSashWindow',
-                             'wxScrolledWindow', 'wxSplitterWindow',
-                             'wxStatusBar', 'wxNotebook',
-                             'wxHtmlWindow',
-                             'wxStyledTextCtrl_1', 'wxStyledTextCtrl_2',]),
-
-    ('Common Dialogs', ['wxColourDialog', 'wxDirDialog', 'wxFileDialog',
-                        'wxSingleChoiceDialog', 'wxTextEntryDialog',
-                        'wxFontDialog', 'wxPageSetupDialog', 'wxPrintDialog',
-                        'wxMessageDialog', 'wxProgressDialog']),
-
-    ('Controls', ['wxButton', 'wxCheckBox', 'wxCheckListBox', 'wxChoice',
-                  'wxComboBox', 'wxGauge', 'wxListBox', 'wxListCtrl', 'wxTextCtrl',
-                  'wxTreeCtrl', 'wxSpinButton', 'wxSpinCtrl', 'wxStaticText',
-                  'wxStaticBitmap', 'wxRadioBox', 'wxSlider', 'wxToolBar',
-                  'wxCalendarCtrl',
-                  ]),
-
-    ('Window Layout', ['wxLayoutConstraints', 'Sizers', ]),
-
-    ('Miscellaneous', [ 'DragAndDrop', 'CustomDragAndDrop', 'FontEnumerator',
-                        'wxTimer', 'wxValidator', 'wxGLCanvas', 'DialogUnits',
-                        'wxImage', 'wxMask', 'PrintFramework', 'wxOGL',
-                        'PythonEvents', 'Threads',
-                        'ActiveXWrapper_Acrobat', 'ActiveXWrapper_IE',
-                        'wxDragImage',
-                        ]),
-
-    ('wxPython Library', ['Layoutf', 'wxScrolledMessageDialog',
-                          'wxMultipleChoiceDialog', 'wxPlotCanvas', 'wxFloatBar',
-                          'PyShell', 'wxCalendar', 'wxMVCTree', 'wxVTKRenderWindow',
-                          'FileBrowseButton', 'GenericButtons', 'wxEditor',
-                          'PyShellWindow',
-                          ]),
-
-    ('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
-
-    ]
-
-#---------------------------------------------------------------------------
-
-class wxPythonDemo(wxFrame):
-
-    def __init__(self, parent, id, title):
-        wxFrame.__init__(self, parent, -1, title, size = (800, 600),
-                         style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
-
-        self.cwd = os.getcwd()
-        self.curOverview = ""
-
-        if wxPlatform == '__WXMSW__':
-            icon = wxIcon('bitmaps/mondrian.ico', wxBITMAP_TYPE_ICO)
-            self.SetIcon(icon)
-
-            # setup a taskbar icon, and catch some events from it
-            self.tbicon = wxTaskBarIcon()
-            self.tbicon.SetIcon(icon, "wxPython Demo")
-            EVT_TASKBAR_LEFT_DCLICK(self.tbicon, self.OnTaskBarActivate)
-            EVT_TASKBAR_RIGHT_UP(self.tbicon, self.OnTaskBarMenu)
-            EVT_MENU(self.tbicon, self.TBMENU_RESTORE, self.OnTaskBarActivate)
-            EVT_MENU(self.tbicon, self.TBMENU_CLOSE, self.OnTaskBarClose)
-
-
-        self.otherWin = None
-        EVT_IDLE(self, self.OnIdle)
-        EVT_CLOSE(self, self.OnCloseWindow)
-
-        self.Centre(wxBOTH)
-        self.CreateStatusBar(1, wxST_SIZEGRIP)
-
-        splitter = wxSplitterWindow(self, -1, style=wxNO_3D|wxSP_3D)
-        splitter2 = wxSplitterWindow(splitter, -1, style=wxNO_3D|wxSP_3D)
-
-
-        # Prevent TreeCtrl from displaying all items after destruction
-        self.dying = false
-
-        # Make a File menu
-        self.mainmenu = wxMenuBar()
-        menu = wxMenu()
-        exitID = wxNewId()
-        menu.Append(exitID, 'E&xit\tAlt-X', 'Get the heck outta here!')
-        EVT_MENU(self, exitID, self.OnFileExit)
-        self.mainmenu.Append(menu, '&File')
-
-        # Make a Demo menu
-        menu = wxMenu()
-        for item in _treeList:
-            submenu = wxMenu()
-            for childItem in item[1]:
-                mID = wxNewId()
-                submenu.Append(mID, childItem)
-                EVT_MENU(self, mID, self.OnDemoMenu)
-            menu.AppendMenu(wxNewId(), item[0], submenu)
-        self.mainmenu.Append(menu, '&Demo')
-
-
-        # Make a Help menu
-        helpID = wxNewId()
-        menu = wxMenu()
-        menu.Append(helpID, '&About\tCtrl-H', 'wxPython RULES!!!')
-        EVT_MENU(self, helpID, self.OnHelpAbout)
-        self.mainmenu.Append(menu, '&Help')
-        self.SetMenuBar(self.mainmenu)
-
-        # set the menu accellerator table...
-        aTable = wxAcceleratorTable([(wxACCEL_ALT,  ord('X'), exitID),
-                                     (wxACCEL_CTRL, ord('H'), helpID)])
-        self.SetAcceleratorTable(aTable)
-
-
-        # Create a TreeCtrl
-        tID = wxNewId()
-        self.treeMap = {}
-        self.tree = wxTreeCtrl(splitter, tID,
-                               style=wxTR_HAS_BUTTONS |
-                               wxTR_EDIT_LABELS |
-                               wxTR_HAS_VARIABLE_ROW_HEIGHT |
-                               wxSUNKEN_BORDER)
-        #self.tree.SetBackgroundColour(wxNamedColour("Pink"))
-        root = self.tree.AddRoot("Overview")
-        firstChild = None
-        for item in _treeList:
-            child = self.tree.AppendItem(root, item[0])
-            if not firstChild: firstChild = child
-            for childItem in item[1]:
-                theDemo = self.tree.AppendItem(child, childItem)
-                self.treeMap[childItem] = theDemo
-
-        self.tree.Expand(root)
-        self.tree.Expand(firstChild)
-        EVT_TREE_ITEM_EXPANDED   (self.tree, tID, self.OnItemExpanded)
-        EVT_TREE_ITEM_COLLAPSED  (self.tree, tID, self.OnItemCollapsed)
-        EVT_TREE_SEL_CHANGED     (self.tree, tID, self.OnSelChanged)
-        EVT_LEFT_DOWN            (self.tree,      self.OnTreeLeftDown)
-
-        # Create a Notebook
-        self.nb = wxNotebook(splitter2, -1)
-
-        # Set up a wxHtmlWindow on the Overview Notebook page
-        # we put it in a panel first because there seems to be a
-        # refresh bug of some sort (wxGTK) when it is directly in
-        # the notebook...
-        if 0:  # the old way
-            self.ovr = wxHtmlWindow(self.nb, -1, size=(400, 400))
-            self.nb.AddPage(self.ovr, "Overview")
-
-        else:  # hopefully I can remove this hacky code soon
-            panel = wxPanel(self.nb, -1)
-            self.ovr = wxHtmlWindow(panel, -1, size=(400, 400))
-            self.nb.AddPage(panel, "Overview")
-
-            def OnOvrSize(evt, ovr=self.ovr):
-                ovr.SetSize(evt.GetSize())
-
-            EVT_SIZE(panel, OnOvrSize)
-
-        self.SetOverview("Overview", overview)
-
-
-        # Set up a TextCtrl on the Demo Code Notebook page
-        self.txt = wxTextCtrl(self.nb, -1,
-                              style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
-        self.txt.SetFont(wxFont(9, wxMODERN, wxNORMAL, wxNORMAL, false))
-        self.nb.AddPage(self.txt, "Demo Code")
-
-
-        # Set up a log on the View Log Notebook page
-        self.log = wxTextCtrl(splitter2, -1,
-                              style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
-        # Set the wxWindows log target to be this textctrl
-        wxLog_SetActiveTarget(wxLogTextCtrl(self.log))
-
-
-
-        self.Show(true)
-
-        # add the windows to the splitter and split it.
-        splitter2.SplitHorizontally(self.nb, self.log)
-        splitter2.SetSashPosition(450, true)
-        splitter2.SetMinimumPaneSize(20)
-
-        splitter.SplitVertically(self.tree, splitter2)
-        splitter.SetSashPosition(180, true)
-        splitter.SetMinimumPaneSize(20)
-
-
-        # select initial items
-        self.nb.SetSelection(0)
-        self.tree.SelectItem(root)
-
-        if len(sys.argv) == 2:
-            try:
-                selectedDemo = self.treeMap[sys.argv[1]]
-            except:
-                selectedDemo = None
-            if selectedDemo:
-                self.tree.SelectItem(selectedDemo)
-                self.tree.EnsureVisible(selectedDemo)
-
-
-        wxLogMessage('window handle: %s' % self.GetHandle())
-
-
-    #---------------------------------------------
-    def WriteText(self, text):
-        if text[-1:] == '\n':
-            text = text[:-1]
-        wxLogMessage(text)
-
-
-    def write(self, txt):
-        self.WriteText(txt)
-
-    #---------------------------------------------
-    def OnItemExpanded(self, event):
-        item = event.GetItem()
-        wxLogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
-        event.Skip()
-
-    #---------------------------------------------
-    def OnItemCollapsed(self, event):
-        item = event.GetItem()
-        wxLogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
-        event.Skip()
-
-    #---------------------------------------------
-    def OnTreeLeftDown(self, event):
-        pt = event.GetPosition();
-        item, flags = self.tree.HitTest(pt)
-        if item == self.tree.GetSelection():
-            self.SetOverview(self.tree.GetItemText(item), self.curOverview)
-        event.Skip()
-
-    #---------------------------------------------
-    def OnSelChanged(self, event):
-        if self.dying:
-            return
-
-        item = event.GetItem()
-        itemText = self.tree.GetItemText(item)
-        self.RunDemo(itemText)
-
-
-    #---------------------------------------------
-    def RunDemo(self, itemText):
-        os.chdir(self.cwd)
-        if self.nb.GetPageCount() == 3:
-            if self.nb.GetSelection() == 2:
-                self.nb.SetSelection(0)
-            self.nb.DeletePage(2)
-
-        if itemText == 'Overview':
-            self.GetDemoFile('Main.py')
-            self.SetOverview('Overview', overview)
-            self.nb.Refresh();
-            self.window = None
-
-        else:
-            if os.path.exists(itemText + '.py'):
-                wxBeginBusyCursor()
-                wxLogMessage("Running demo %s.py..." % itemText)
-                try:
-                    self.GetDemoFile(itemText + '.py')
-                    module = __import__(itemText, globals())
-                    self.SetOverview(itemText, module.overview)
-                finally:
-                    wxEndBusyCursor()
-
-                # in case runTest is modal, make sure things look right...
-                self.nb.Refresh();
-                wxYield()
-
-                self.window = module.runTest(self, self.nb, self) ###
-                if self.window:
-                    self.nb.AddPage(self.window, 'Demo')
-                    wxYield()
-                    self.nb.SetSelection(2)
-
-            else:
-                self.ovr.SetPage("")
-                self.txt.Clear()
-                self.window = None
-
-
-
-    #---------------------------------------------
-    # Get the Demo files
-    def GetDemoFile(self, filename):
-        self.txt.Clear()
-        try:
-            self.txt.SetValue(open(filename).read())
-        except IOError:
-            self.txt.WriteText("Cannot open %s file." % filename)
-
-        self.txt.SetInsertionPoint(0)
-        self.txt.ShowPosition(0)
-
-    #---------------------------------------------
-    def SetOverview(self, name, text):
-        self.curOverview = text
-        lead = text[:6]
-        if lead != '<html>' and lead != '<HTML>':
-            text = string.join(string.split(text, '\n'), '<br>')
-            #text = '<font size="-1"><pre>' + text + '</pre></font>'
-        self.ovr.SetPage(text)
-        self.nb.SetPageText(0, name)
-
-    #---------------------------------------------
-    # Menu methods
-    def OnFileExit(self, *event):
-        self.Close()
-
-
-    def OnHelpAbout(self, event):
-        from About import MyAboutBox
-        about = MyAboutBox(self)
-        about.ShowModal()
-        about.Destroy()
-
-
-    #---------------------------------------------
-    def OnCloseWindow(self, event):
-        self.dying = true
-        self.window = None
-        self.mainmenu = None
-        if hasattr(self, "tbicon"):
-            del self.tbicon
-        self.Destroy()
-
-
-    #---------------------------------------------
-    def OnIdle(self, event):
-        if self.otherWin:
-            self.otherWin.Raise()
-            self.window = self.otherWin
-            self.otherWin = None
-
-    #---------------------------------------------
-    def OnDemoMenu(self, event):
-        try:
-            selectedDemo = self.treeMap[self.mainmenu.GetLabel(event.GetId())]
-        except:
-            selectedDemo = None
-        if selectedDemo:
-            self.tree.SelectItem(selectedDemo)
-            self.tree.EnsureVisible(selectedDemo)
-
-
-    #---------------------------------------------
-    def OnTaskBarActivate(self, evt):
-        if self.IsIconized():
-            self.Iconize(false)
-        if not self.IsShown():
-            self.Show(true)
-        self.Raise()
-
-    #---------------------------------------------
-
-    TBMENU_RESTORE = 1000
-    TBMENU_CLOSE   = 1001
-
-    def OnTaskBarMenu(self, evt):
-        menu = wxMenu()
-        menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
-        menu.Append(self.TBMENU_CLOSE,   "Close")
-        self.tbicon.PopupMenu(menu)
-        menu.Destroy()
-
-    #---------------------------------------------
-    def OnTaskBarClose(self, evt):
-        self.Close()
-
-        # because of the way wxTaskBarIcon.PopupMenu is implemented we have to
-        # prod the main idle handler a bit to get the window to actually close
-        wxGetApp().ProcessIdle()
-
-
-#---------------------------------------------------------------------------
-#---------------------------------------------------------------------------
-
-class MyApp(wxApp):
-    def OnInit(self):
-        wxInitAllImageHandlers()
-
-        self.splash = SplashScreen(None, bitmapfile='bitmaps/splash.gif',
-                              duration=4000, callback=self.AfterSplash)
-        self.splash.Show(true)
-        wxYield()
-        return true
-
-
-    def AfterSplash(self):
-        self.splash.Close(true)
-        frame = wxPythonDemo(None, -1, "wxPython: (A Demonstration)")
-        frame.Show(true)
-        self.SetTopWindow(frame)
-        self.ShowTip(frame)
-
-
-    def ShowTip(self, frame):
-        try:
-            showTipText = open("data/showTips").read()
-            showTip, index = eval(showTipText)
-        except IOError:
-            showTip, index = (1, 0)
-        #print showTip, index
-        if showTip:
-            tp = wxCreateFileTipProvider("data/tips.txt", index)
-            showTip = wxShowTip(frame, tp)
-            index = tp.GetCurrentTip()
-            open("data/showTips", "w").write(str( (showTip, index) ))
-
-
-#---------------------------------------------------------------------------
-
-def main():
-    try:
-        demoPath = os.path.split(__file__)[0]
-        os.chdir(demoPath)
-    except:
-        pass
-    app = MyApp(0)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------
-
-
-
-overview = """<html><body>
- <h2>Python</h2>
-
- Python is an interpreted, interactive, object-oriented programming
- language often compared to Tcl, Perl, Scheme, or Java.
-
- <p> Python combines remarkable power with very clear syntax. It has
- modules, classes, exceptions, very high level dynamic data types, and
- dynamic typing.  There are interfaces to many system calls and
- libraries, and new built-in modules are easily written in C or
- C++. Python is also usable as an extension language for applications
- that need a programmable interface.  <p>
-
- <h2>wxWindows</h2>
-
- wxWindows is a free C++ framework designed to make cross-platform
- programming child's play. Well, almost. wxWindows 2 supports Windows
- 3.1/95/98/NT, Unix with GTK/Motif/Lesstif, with a Mac version
- underway. Other ports are under consideration.  <p>
-
- wxWindows is a set of libraries that allows C++ applications to
- compile and run on several different types of computers, with minimal
- source code changes.  There is one library per supported GUI (such as
- Motif, or Windows). As well as providing a common API (Application
- Programming Interface) for GUI functionality, it provides
- functionality for accessing some commonly-used operating system
- facilities, such as copying or deleting files. wxWindows is a
- 'framework' in the sense that it provides a lot of built-in
- functionality, which the application can use or replace as required,
- thus saving a great deal of coding effort. Basic data structures such
- as strings, linked lists and hash tables are also supported.
-
- <p>
- <h2>wxPython</h2>
-
- wxPython is a Python extension module that encapsulates the wxWindows
- GUI classes. Currently it is only available for the Win32 and GTK
- ports of wxWindows, but as soon as the other ports are brought up to
- the same level as Win32 and GTK, it should be fairly trivial to
- enable wxPython to be used with the new GUI.
-
- <p>
-
- The wxPython extension module attempts to mirror the class heiarchy
- of wxWindows as closely as possible. 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. Unfortunately,
- because of differences in the languages, wxPython doesn't match
- wxWindows exactly, but the differences should be easy to absorb
- because they are natural to Python. For example, some methods that
- return multiple values via argument pointers in C++ will return a
- tuple of values in Python.
-
- <p>
-
- There is still much to be done for wxPython, many classes still need
- to be mirrored. Also, wxWindows is still somewhat of a moving target
- so it is a bit of an effort just keeping wxPython up to date. On the
- other hand, there are enough of the core classes completed that
- useful applications can be written.
-
- <p>
-
- wxPython is close enough to the C++ version that the majority of
- the wxPython documentation is actually just notes attached to the C++
- documents that describe the places where wxPython is different. There
- is also a series of sample programs included, and a series of
- documentation pages that assist the programmer in getting started
- with wxPython.
-
- """
-
-
-#----------------------------------------------------------------------------
-#----------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    main()
-
-#----------------------------------------------------------------------------
-
-
-
-
-
-
-

wxPython/demo/PrintFramework.py

@@ -1,176 +0,0 @@
-
-from wxPython.wx         import *
-from wxScrolledWindow    import MyCanvas
-
-#----------------------------------------------------------------------
-
-class MyPrintout(wxPrintout):
-    def __init__(self, canvas, log):
-        wxPrintout.__init__(self)
-        self.canvas = canvas
-        self.log = log
-
-    def OnBeginDocument(self, start, end):
-        self.log.WriteText("wxPrintout.OnBeginDocument\n")
-        return self.base_OnBeginDocument(start, end)
-
-    def OnEndDocument(self):
-        self.log.WriteText("wxPrintout.OnEndDocument\n")
-        self.base_OnEndDocument()
-
-    def OnBeginPrinting(self):
-        self.log.WriteText("wxPrintout.OnBeginPrinting\n")
-        self.base_OnBeginPrinting()
-
-    def OnEndPrinting(self):
-        self.log.WriteText("wxPrintout.OnEndPrinting\n")
-        self.base_OnEndPrinting()
-
-    def OnPreparePrinting(self):
-        self.log.WriteText("wxPrintout.OnPreparePrinting\n")
-        self.base_OnPreparePrinting()
-
-    def HasPage(self, page):
-        self.log.WriteText("wxPrintout.HasPage\n")
-        if page == 1:
-            return true
-        else:
-            return false
-
-    def GetPageInfo(self):
-        self.log.WriteText("wxPrintout.GetPageInfo\n")
-        return (1, 1, 1, 1)
-
-    def OnPrintPage(self, page):
-        self.log.WriteText("wxPrintout.OnPrintPage\n")
-        dc = self.GetDC()
-
-        #-------------------------------------------
-        # One possible method of setting scaling factors...
-
-        maxX = self.canvas.getWidth()
-        maxY = self.canvas.getHeight()
-
-        # Let's have at least 50 device units margin
-        marginX = 50
-        marginY = 50
-
-        # Add the margin to the graphic size
-        maxX = maxX + (2 * marginX)
-        maxY = maxY + (2 * marginY)
-
-        # Get the size of the DC in pixels
-        (w, h) = dc.GetSizeTuple()
-
-        # Calculate a suitable scaling factor
-        scaleX = float(w) / maxX
-        scaleY = float(h) / maxY
-
-        # Use x or y scaling factor, whichever fits on the DC
-        actualScale = min(scaleX, scaleY)
-
-        # Calculate the position on the DC for centring the graphic
-        posX = (w - (self.canvas.getWidth() * actualScale)) / 2.0
-        posY = (h - (self.canvas.getHeight() * actualScale)) / 2.0
-
-        # Set the scale and origin
-        dc.SetUserScale(actualScale, actualScale)
-        dc.SetDeviceOrigin(int(posX), int(posY))
-
-        #-------------------------------------------
-
-        self.canvas.DoDrawing(dc)
-        return true
-
-
-#----------------------------------------------------------------------
-
-
-class TestPrintPanel(wxPanel):
-    def __init__(self, parent, frame, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-        self.frame = frame
-
-
-        self.printData = wxPrintData()
-        self.printData.SetPaperId(wxPAPER_LETTER)
-
-        self.box = wxBoxSizer(wxVERTICAL)
-        self.canvas = MyCanvas(self)
-        self.box.Add(self.canvas, 1, wxGROW)
-
-        subbox = wxBoxSizer(wxHORIZONTAL)
-        btn = wxButton(self, 1201, "Print Setup")
-        EVT_BUTTON(self, 1201, self.OnPrintSetup)
-        subbox.Add(btn, 1, wxGROW | wxALL, 2)
-
-        btn = wxButton(self, 1202, "Print Preview")
-        EVT_BUTTON(self, 1202, self.OnPrintPreview)
-        subbox.Add(btn, 1, wxGROW | wxALL, 2)
-
-        btn = wxButton(self, 1203, "Print")
-        EVT_BUTTON(self, 1203, self.OnDoPrint)
-        subbox.Add(btn, 1, wxGROW | wxALL, 2)
-
-        self.box.Add(subbox, 0, wxGROW)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(self.box)
-
-
-    def OnPrintSetup(self, event):
-        printerDialog = wxPrintDialog(self)
-        printerDialog.GetPrintDialogData().SetPrintData(self.printData)
-        printerDialog.GetPrintDialogData().SetSetupDialog(true)
-        printerDialog.ShowModal();
-        self.printData = printerDialog.GetPrintDialogData().GetPrintData()
-        printerDialog.Destroy()
-
-
-    def OnPrintPreview(self, event):
-        self.log.WriteText("OnPrintPreview\n")
-        printout = MyPrintout(self.canvas, self.log)
-        printout2 = MyPrintout(self.canvas, self.log)
-        self.preview = wxPrintPreview(printout, printout2, self.printData)
-        if not self.preview.Ok():
-            self.log.WriteText("Houston, we have a problem...\n")
-            return
-
-        frame = wxPreviewFrame(self.preview, self.frame, "This is a print preview")
-
-        frame.Initialize()
-        frame.SetPosition(self.frame.GetPosition())
-        frame.SetSize(self.frame.GetSize())
-        frame.Show(true)
-
-
-
-    def OnDoPrint(self, event):
-        pdd = wxPrintDialogData()
-        pdd.SetPrintData(self.printData)
-        printer = wxPrinter(pdd)
-        printout = MyPrintout(self.canvas, self.log)
-        if not printer.Print(self.frame, printout):
-            wxMessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wxOK)
-        else:
-            self.printData = printer.GetPrintDialogData().GetPrintData()
-        printout.Destroy()
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPrintPanel(nb, frame, log)
-    return win
-
-
-#----------------------------------------------------------------------
-
-
-
-
-
-overview = """\
-"""
-

wxPython/demo/PyShell.py

@@ -1,21 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib.shell import PyShell
-
-#----------------------------------------------------------------------
-
-
-def runTest(frame, nb, log):
-    testGlobals = {'hello' : 'How are you?'}
-    win = PyShell(nb, globals=testGlobals)
-    win.Show(true)
-    return win
-
-
-#----------------------------------------------------------------------
-
-
-overview = """
-A simple GUI version of the interactive interpreter.
-"""
-

wxPython/demo/PyShellWindow.py

@@ -1,15 +0,0 @@
-
-
-from wxPython.lib.pyshell import PyShellWindow
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = PyShellWindow(nb, -1)
-    return win
-
-#----------------------------------------------------------------------
-
-import wxPython.lib.pyshell
-
-overview = wxPython.lib.pyshell.__doc__

wxPython/demo/PythonEvents.py

@@ -1,85 +0,0 @@
-
-from wxPython.wx import *
-import sys
-
-#----------------------------------------------------------------------
-
-myEVT_BUTTON_CLICKPOS = 5015
-
-def EVT_BUTTON_CLICKPOS(win, id, func):
-    win.Connect(id, -1, myEVT_BUTTON_CLICKPOS, func)
-
-
-
-class MyEvent(wxPyCommandEvent):
-    def __init__(self, evtType, id):
-        wxPyCommandEvent.__init__(self, evtType, id)
-        self.myVal = None
-
-    #def __del__(self):
-    #    print '__del__'
-    #    wxPyCommandEvent.__del__(self)
-
-    def SetMyVal(self, val):
-        self.myVal = val
-
-    def GetMyVal(self):
-        return self.myVal
-
-
-
-class MyButton(wxButton):
-    def __init__(self, parent, id, txt, pos):
-        wxButton.__init__(self, parent, id, txt, pos)
-        EVT_LEFT_DOWN(self, self.OnLeftDown)
-
-    def OnLeftDown(self, event):
-        pt = event.GetPosition()
-        evt = MyEvent(myEVT_BUTTON_CLICKPOS, self.GetId())
-        evt.SetMyVal(pt)
-        #print id(evt), sys.getrefcount(evt)
-        self.GetEventHandler().ProcessEvent(evt)
-        #print id(evt), sys.getrefcount(evt)
-        event.Skip()
-
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        b = MyButton(self, -1, " Click me ", wxPoint(30,30))
-        EVT_BUTTON(self, b.GetId(), self.OnClick)
-        EVT_BUTTON_CLICKPOS(self, b.GetId(), self.OnMyEvent)
-
-        wxStaticText(self, -1, "Please see the Overview and Demo Code for details...",
-                     wxPoint(30, 80))
-
-
-    def OnClick(self, event):
-        self.log.WriteText("OnClick\n")
-
-    def OnMyEvent(self, event):
-        #print id(event), sys.getrefcount(event)
-        self.log.WriteText("MyEvent: %s\n" % (event.GetMyVal(), ) )
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-#----------------------------------------------------------------------
-
-
-
-
-overview = """\
-This demo is a contrived example of defining an event class in wxPython and sending it up the containment heirachy for processing.
-"""
-
-
-
-

wxPython/demo/README.txt

@@ -1,7 +0,0 @@
-To run the main demo in this directory, execute demo.py.  In other
-words, one of the following commands should do it:
-
-       demo.py
-       python demo.py
-       pythonw demo.py
-

wxPython/demo/Sizers.py

@@ -1,587 +0,0 @@
-#----------------------------------------------------------------------
-# sizer test code
-#----------------------------------------------------------------------
-
-from wxPython.wx             import *
-from wxPython.lib.grids      import wxGridSizer, wxFlexGridSizer
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox1(win):
-    box = wxBoxSizer(wxHORIZONTAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox2(win):
-    box = wxBoxSizer(wxVERTICAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox3(win):
-    box = wxBoxSizer(wxHORIZONTAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox4(win):
-    box = wxBoxSizer(wxHORIZONTAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 1, wxEXPAND)
-    box.Add(wxButton(win, 1010, "four"), 1, wxEXPAND)
-    box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox5(win):
-    box = wxBoxSizer(wxHORIZONTAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 3, wxEXPAND)
-    box.Add(wxButton(win, 1010, "four"), 1, wxEXPAND)
-    box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox6(win):
-    box = wxBoxSizer(wxHORIZONTAL)
-    box.Add(wxButton(win, 1010, "one"), 1, wxALIGN_TOP)
-    box.Add(wxButton(win, 1010, "two"), 1, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 1, wxALIGN_CENTER)
-    box.Add(wxButton(win, 1010, "four"), 1, wxEXPAND)
-    box.Add(wxButton(win, 1010, "five"), 1, wxALIGN_BOTTOM)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox7(win):
-    box = wxBoxSizer(wxHORIZONTAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
-    box.Add(60, 20, 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeSimpleBox8(win):
-    box = wxBoxSizer(wxVERTICAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(0,0, 1)
-    box.Add(wxButton(win, 1010, "two"), 0, wxALIGN_CENTER)
-    box.Add(0,0, 1)
-    box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
-#    box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-
-def makeSimpleBorder1(win):
-    bdr = wxBoxSizer(wxHORIZONTAL)
-    btn = wxButton(win, 1010, "border")
-    btn.SetSize(wxSize(80, 80))
-    bdr.Add(btn, 1, wxEXPAND|wxALL, 15)
-
-    return bdr
-
-#----------------------------------------------------------------------
-
-def makeSimpleBorder2(win):
-    bdr = wxBoxSizer(wxHORIZONTAL)
-    btn = wxButton(win, 1010, "border")
-    btn.SetSize(wxSize(80, 80))
-    bdr.Add(btn, 1, wxEXPAND | wxEAST | wxWEST, 15)
-
-    return bdr
-
-#----------------------------------------------------------------------
-
-def makeSimpleBorder3(win):
-    bdr = wxBoxSizer(wxHORIZONTAL)
-    btn = wxButton(win, 1010, "border")
-    btn.SetSize(wxSize(80, 80))
-    bdr.Add(btn, 1, wxEXPAND | wxNORTH | wxWEST, 15)
-
-    return bdr
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-
-def makeBoxInBox(win):
-    box = wxBoxSizer(wxVERTICAL)
-
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-
-    box2 = wxBoxSizer(wxHORIZONTAL)
-    box2.AddMany([ (wxButton(win, 1010, "two"), 0, wxEXPAND),
-                   (wxButton(win, 1010, "three"), 0, wxEXPAND),
-                   (wxButton(win, 1010, "four"), 0, wxEXPAND),
-                   (wxButton(win, 1010, "five"), 0, wxEXPAND),
-                   ])
-
-    box3 = wxBoxSizer(wxVERTICAL)
-    box3.AddMany([ (wxButton(win, 1010, "six"),   0, wxEXPAND),
-                   (wxButton(win, 1010, "seven"), 2, wxEXPAND),
-                   (wxButton(win, 1010, "eight"), 1, wxEXPAND),
-                   (wxButton(win, 1010, "nine"),  1, wxEXPAND),
-                   ])
-
-    box2.Add(box3, 1, wxEXPAND)
-    box.Add(box2, 1, wxEXPAND)
-
-    box.Add(wxButton(win, 1010, "ten"), 0, wxEXPAND)
-
-    return box
-
-#----------------------------------------------------------------------
-
-def makeBoxInBorder(win):
-    bdr = wxBoxSizer(wxHORIZONTAL)
-    box = makeSimpleBox3(win)
-    bdr.Add(box, 1, wxEXPAND | wxALL, 15)
-
-    return bdr
-
-#----------------------------------------------------------------------
-
-def makeBorderInBox(win):
-    insideBox = wxBoxSizer(wxHORIZONTAL)
-
-    box2 = wxBoxSizer(wxHORIZONTAL)
-    box2.AddMany([ (wxButton(win, 1010, "one"), 0, wxEXPAND),
-                   (wxButton(win, 1010, "two"), 0, wxEXPAND),
-                   (wxButton(win, 1010, "three"), 0, wxEXPAND),
-                   (wxButton(win, 1010, "four"), 0, wxEXPAND),
-                   (wxButton(win, 1010, "five"), 0, wxEXPAND),
-                 ])
-
-    insideBox.Add(box2, 0, wxEXPAND)
-
-    bdr = wxBoxSizer(wxHORIZONTAL)
-    bdr.Add(wxButton(win, 1010, "border"), 1, wxEXPAND | wxALL)
-    insideBox.Add(bdr, 1, wxEXPAND | wxALL, 20)
-
-    box3 = wxBoxSizer(wxVERTICAL)
-    box3.AddMany([ (wxButton(win, 1010, "six"),   0, wxEXPAND),
-                   (wxButton(win, 1010, "seven"), 2, wxEXPAND),
-                   (wxButton(win, 1010, "eight"), 1, wxEXPAND),
-                   (wxButton(win, 1010, "nine"),  1, wxEXPAND),
-                 ])
-    insideBox.Add(box3, 1, wxEXPAND)
-
-    outsideBox = wxBoxSizer(wxVERTICAL)
-    outsideBox.Add(wxButton(win, 1010, "top"), 0, wxEXPAND)
-    outsideBox.Add(insideBox, 1, wxEXPAND)
-    outsideBox.Add(wxButton(win, 1010, "bottom"), 0, wxEXPAND)
-
-    return outsideBox
-
-
-#----------------------------------------------------------------------
-
-def makeGrid1(win):
-    gs = wxGridSizer(3, 3, 2, 2)  # rows, cols, hgap, vgap
-
-    gs.AddMany([ (wxButton(win, 1010, 'one'),   0, wxEXPAND),
-                 (wxButton(win, 1010, 'two'),   0, wxEXPAND),
-                 (wxButton(win, 1010, 'three'), 0, wxEXPAND),
-                 (wxButton(win, 1010, 'four'),  0, wxEXPAND),
-                 (wxButton(win, 1010, 'five'),  0, wxEXPAND),
-                 #(75, 50),
-                 (wxButton(win, 1010, 'six'),   0, wxEXPAND),
-                 (wxButton(win, 1010, 'seven'), 0, wxEXPAND),
-                 (wxButton(win, 1010, 'eight'), 0, wxEXPAND),
-                 (wxButton(win, 1010, 'nine'),  0, wxEXPAND),
-                 ])
-
-    return gs
-
-#----------------------------------------------------------------------
-
-def makeGrid2(win):
-    gs = wxGridSizer(3, 3)  # rows, cols, hgap, vgap
-
-    box = wxBoxSizer(wxVERTICAL)
-    box.Add(wxButton(win, 1010, 'A'), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, 'B'), 1, wxEXPAND)
-
-    gs2 = wxGridSizer(2,2, 4, 4)
-    gs2.AddMany([ (wxButton(win, 1010, 'C'), 0, wxEXPAND),
-                  (wxButton(win, 1010, 'E'), 0, wxEXPAND),
-                  (wxButton(win, 1010, 'F'), 0, wxEXPAND),
-                  (wxButton(win, 1010, 'G'), 0, wxEXPAND)])
-
-    gs.AddMany([ (wxButton(win, 1010, 'one'),   0, wxALIGN_RIGHT | wxALIGN_BOTTOM),
-                 (wxButton(win, 1010, 'two'),   0, wxEXPAND),
-                 (wxButton(win, 1010, 'three'), 0, wxALIGN_LEFT | wxALIGN_BOTTOM),
-                 (wxButton(win, 1010, 'four'),  0, wxEXPAND),
-                 (wxButton(win, 1010, 'five'),  0, wxALIGN_CENTER),
-                 (wxButton(win, 1010, 'six'),   0, wxEXPAND),
-                 (box,                          0, wxEXPAND | wxALL, 10),
-                 (wxButton(win, 1010, 'eight'), 0, wxEXPAND),
-                 (gs2,                          0, wxEXPAND | wxALL, 4),
-                 ])
-
-    return gs
-
-#----------------------------------------------------------------------
-
-def makeGrid3(win):
-    gs = wxFlexGridSizer(3, 3, 2, 2)  # rows, cols, hgap, vgap
-
-    gs.AddMany([ (wxButton(win, 1010, 'one'),   0, wxEXPAND),
-                 (wxButton(win, 1010, 'two'),   0, wxEXPAND),
-                 (wxButton(win, 1010, 'three'), 0, wxEXPAND),
-                 (wxButton(win, 1010, 'four'),  0, wxEXPAND),
-                 #(wxButton(win, 1010, 'five'),  0, wxEXPAND),
-                 (175, 50),
-                 (wxButton(win, 1010, 'six'),   0, wxEXPAND),
-                 (wxButton(win, 1010, 'seven'), 0, wxEXPAND),
-                 (wxButton(win, 1010, 'eight'), 0, wxEXPAND),
-                 (wxButton(win, 1010, 'nine'),  0, wxEXPAND),
-                 ])
-
-    gs.AddGrowableRow(0)
-    gs.AddGrowableRow(2)
-    gs.AddGrowableCol(1)
-    return gs
-
-#----------------------------------------------------------------------
-
-def makeGrid4(win):
-    bpos = wxDefaultPosition
-    bsize = wxSize(100, 50)
-    gs = wxGridSizer(3, 3, 2, 2)  # rows, cols, hgap, vgap
-
-    gs.AddMany([ (wxButton(win, 1010, 'one', bpos, bsize),
-                  0, wxALIGN_TOP | wxALIGN_LEFT ),
-                 (wxButton(win, 1010, 'two', bpos, bsize),
-                  0, wxALIGN_TOP | wxALIGN_CENTER_HORIZONTAL ),
-                 (wxButton(win, 1010, 'three', bpos, bsize),
-                  0, wxALIGN_TOP | wxALIGN_RIGHT ),
-                 (wxButton(win, 1010, 'four', bpos, bsize),
-                  0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT ),
-                 (wxButton(win, 1010, 'five', bpos, bsize),
-                  0, wxALIGN_CENTER ),
-                 (wxButton(win, 1010, 'six', bpos, bsize),
-                  0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT ),
-                 (wxButton(win, 1010, 'seven', bpos, bsize),
-                  0, wxALIGN_BOTTOM | wxALIGN_LEFT ),
-                 (wxButton(win, 1010, 'eight', bpos, bsize),
-                  0, wxALIGN_BOTTOM | wxALIGN_CENTER_HORIZONTAL ),
-                 (wxButton(win, 1010, 'nine', bpos, bsize),
-                  0, wxALIGN_BOTTOM | wxALIGN_RIGHT ),
-                 ])
-
-    return gs
-
-#----------------------------------------------------------------------
-
-def makeShapes(win):
-    bpos = wxDefaultPosition
-    bsize = wxSize(100, 50)
-    gs = wxGridSizer(3, 3, 2, 2)  # rows, cols, hgap, vgap
-
-    gs.AddMany([ (wxButton(win, 1010, 'one', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_TOP | wxALIGN_LEFT ),
-                 (wxButton(win, 1010, 'two', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_TOP | wxALIGN_CENTER_HORIZONTAL ),
-                 (wxButton(win, 1010, 'three', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_TOP | wxALIGN_RIGHT ),
-                 (wxButton(win, 1010, 'four', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT ),
-                 (wxButton(win, 1010, 'five', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_CENTER ),
-                 (wxButton(win, 1010, 'six', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT ),
-                 (wxButton(win, 1010, 'seven', bpos, bsize),
-                  0, wxSHAPED |  wxALIGN_BOTTOM | wxALIGN_LEFT ),
-                 (wxButton(win, 1010, 'eight', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_BOTTOM | wxALIGN_CENTER_HORIZONTAL ),
-                 (wxButton(win, 1010, 'nine', bpos, bsize),
-                  0, wxSHAPED | wxALIGN_BOTTOM | wxALIGN_RIGHT ),
-                 ])
-
-    return gs
-
-#----------------------------------------------------------------------
-
-def makeSimpleBoxShaped(win):
-    box = wxBoxSizer(wxHORIZONTAL)
-    box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
-    box.Add(wxButton(win, 1010, "five"), 1, wxSHAPED)
-
-    return box
-
-#----------------------------------------------------------------------
-
-theTests = [
-    ("Simple horizontal boxes", makeSimpleBox1,
-     "This is a HORIZONTAL box sizer with four non-stretchable buttons held "
-     "within it.  Notice that the buttons are added and aligned in the horizontal "
-     "dimension.  Also notice that they are fixed size in the horizontal dimension, "
-     "but will stretch vertically."
-     ),
-
-    ("Simple vertical boxes", makeSimpleBox2,
-     "Exactly the same as the previous sample but using a VERTICAL box sizer "
-     "instead of a HORIZONTAL one."
-     ),
-
-    ("Add a stretchable", makeSimpleBox3,
-     "We've added one more button with the strechable flag turned on.  Notice "
-     "how it grows to fill the extra space in the otherwise fixed dimension."
-     ),
-
-    ("More than one stretchable", makeSimpleBox4,
-     "Here there are several items that are stretchable, they all divide up the "
-     "extra space evenly."
-     ),
-
-    ("Weighting factor", makeSimpleBox5,
-     "This one shows more than one strechable, but one of them has a weighting "
-     "factor so it gets more of the free space."
-     ),
-
-    ("Edge Affinity", makeSimpleBox6,
-     "For items that don't completly fill their allotted space, and don't "
-     "stretch, you can specify which side (or the center) they should stay "
-     "attached to."
-     ),
-
-    ("Spacer", makeSimpleBox7,
-     "You can add empty space to be managed by a Sizer just as if it were a "
-     "window or another Sizer."
-     ),
-
-    ("Centering in available space", makeSimpleBox8,
-     "This one shows an item that does not expand to fill it's space, but rather"
-     "stays centered within it."
-     ),
-
-#    ("Percent Sizer", makeSimpleBox6,
-#     "You can use the wxBoxSizer like a Percent Sizer.  Just make sure that all "
-#     "the weighting factors add up to 100!"
-#     ),
-
-    ("", None, ""),
-
-    ("Simple border sizer", makeSimpleBorder1,
-     "The wxBoxSizer can leave empty space around its contents.  This one "
-     "gives a border all the way around."
-     ),
-
-    ("East and West border", makeSimpleBorder2,
-     "You can pick and choose which sides have borders."
-     ),
-
-    ("North and West border", makeSimpleBorder3,
-     "You can pick and choose which sides have borders."
-     ),
-
-    ("", None, ""),
-
-    ("Boxes inside of boxes", makeBoxInBox,
-     "This one shows nesting of boxes within boxes within boxes, using both "
-     "orientations.  Notice also that button seven has a greater weighting "
-     "factor than its siblings."
-     ),
-
-    ("Boxes inside a Border", makeBoxInBorder,
-     "Sizers of different types can be nested withing each other as well. "
-     "Here is a box sizer with several buttons embedded within a border sizer."
-     ),
-
-    ("Border in a Box", makeBorderInBox,
-     "Another nesting example.  This one has Boxes and a Border inside another Box."
-     ),
-
-    ("", None, ""),
-
-    ("Simple Grid", makeGrid1,
-     "This is an example of the wxGridSizer.  In this case all row heights "
-     "and column widths are kept the same as all the others and all items "
-     "fill their available space.  The horzontal and vertical gaps are set to "
-     "2 pixels each."
-     ),
-
-    ("More Grid Features", makeGrid2,
-     "This is another example of the wxGridSizer.  This one has no gaps in the grid, "
-     "but various cells are given different alignment options and some of them "
-     "hold nested sizers."
-     ),
-
-    ("Flexible Grid", makeGrid3,
-     "This grid allows the rows to have different heights and the columns to have "
-     "different widths.  You can also specify rows and columns that are growable, "
-     "which we have done for the first and last row and the middle column for "
-     "this example.\n"
-     "\nThere is also a spacer in the middle cell instead of an actual window."
-     ),
-
-    ("Grid with Alignment", makeGrid4,
-     "New alignment flags allow for the positioning of items in any corner or centered "
-     "position."
-     ),
-
-    ("", None, ""),
-
-    ("Proportional resize", makeSimpleBoxShaped,
-     "Managed items can preserve their original aspect ratio.  The last item has the "
-     "wxSHAPED flag set and will resize proportional to its origingal size."
-     ),
-
-    ("Proportional resize with Alignments", makeShapes,
-     "This one shows various alignments as well as proportional resizing for all items."
-     ),
-
-    ]
-#----------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, title, sizerFunc):
-        wxFrame.__init__(self, parent, -1, title)
-        EVT_BUTTON(self, 1010, self.OnButton)
-
-        self.sizer = sizerFunc(self)
-        self.CreateStatusBar()
-        self.SetStatusText("Resize this frame to see how the sizers respond...")
-        self.sizer.Fit(self)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(self.sizer)
-        EVT_CLOSE(self, self.OnCloseWindow)
-
-    def OnCloseWindow(self, event):
-        self.MakeModal(false)
-        self.Destroy()
-
-    def OnButton(self, event):
-        self.Close(true)
-
-#----------------------------------------------------------------------
-
-
-
-class TestSelectionPanel(wxPanel):
-    def __init__(self, parent, frame):
-        wxPanel.__init__(self, parent, -1)
-        self.frame = frame
-
-        self.list = wxListBox(self, 401,
-                              wxDLG_PNT(self, 10, 10), wxDLG_SZE(self, 100, 100),
-                              [])
-        EVT_LISTBOX(self, 401, self.OnSelect)
-        EVT_LISTBOX_DCLICK(self, 401, self.OnDClick)
-
-        self.btn = wxButton(self, 402, "Try it!", wxDLG_PNT(self, 120, 10)).SetDefault()
-        EVT_BUTTON(self, 402, self.OnDClick)
-
-        self.text = wxTextCtrl(self, -1, "",
-                               wxDLG_PNT(self, 10, 115),
-                               wxDLG_SZE(self, 200, 50),
-                               wxTE_MULTILINE | wxTE_READONLY)
-
-        for item in theTests:
-            self.list.Append(item[0])
-
-
-
-    def OnSelect(self, event):
-        pos = self.list.GetSelection()
-        self.text.SetValue(theTests[pos][2])
-
-
-    def OnDClick(self, event):
-        pos = self.list.GetSelection()
-        title = theTests[pos][0]
-        func = theTests[pos][1]
-
-        if func:
-            win = TestFrame(self, title, func)
-            win.CentreOnParent(wxBOTH)
-            win.Show(true)
-            win.MakeModal(true)
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestSelectionPanel(nb, frame)
-    return win
-
-overview = ""
-#wxSizer.__doc__        + '\n' + '-' * 80 + '\n' + \
-#wxBoxSizer.__doc__     + '\n' + '-' * 80 + '\n' + \
-#wxBorderSizer.__doc__
-
-#----------------------------------------------------------------------
-
-
-
-if __name__ == '__main__':
-
-    class MainFrame(wxFrame):
-        def __init__(self):
-            wxFrame.__init__(self, NULL, -1, "Testing...")
-
-	    self.CreateStatusBar()
-	    mainmenu = wxMenuBar()
-	    menu = wxMenu()
-	    menu.Append(200, 'E&xit', 'Get the heck outta here!')
-	    mainmenu.Append(menu, "&File")
-	    self.SetMenuBar(mainmenu)
-            EVT_MENU(self, 200, self.OnExit)
-            self.panel = TestSelectionPanel(self, self)
-            self.SetSize(wxSize(400, 380))
-            EVT_CLOSE(self, self.OnCloseWindow)
-
-        def OnCloseWindow(self, event):
-            self.Destroy()
-
-        def OnExit(self, event):
-            self.Close(true)
-
-
-    class TestApp(wxApp):
-        def OnInit(self):
-            frame = MainFrame()
-            frame.Show(true)
-            self.SetTopWindow(frame)
-            return true
-
-    app = TestApp(0)
-    app.MainLoop()
-
-
-#----------------------------------------------------------------------

wxPython/demo/SlashDot.py

@@ -1,379 +0,0 @@
-#!/usr/bin/python
-"""This is SlashDot 1.2
-
-    It's the obligatory Slashdot.org headlines reader that
-any modern widget set/library must have in order to be taken
-seriously :-)
-
-    Usage is quite simple; wxSlash attempts to download the
-'ultramode.txt' file from http://slashdot.org, which
-contains the headlines in a computer friendly format. It
-then displays said headlines in a wxWindows list control.
-
-    You can read articles using either Python's html library
-or an external browser. Uncheck the 'browser->internal' menu
-item to use the latter option.  Use the settings dialog box
-to set which external browser is started.
-
-    This code is available under the wxWindows license, see
-elsewhere. If you modify this code, be aware of the fact
-that slashdot.org's maintainer, CmdrTaco, explicitly asks
-'ultramode.txt' downloaders not to do this automatically
-more than twice per hour. If this feature is abused,
-CmdrTaco may remove the ultramode file completely and that
-will make a *lot* of people unhappy.
-
-    I want to thank Alex Shnitman whose slashes.pl
-(Perl/GTK) script gave me the idea for this applet.
-
-    Have fun with it,
-
-    Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)
-"""
-
-from wxPython.wx import *
-from httplib import HTTP
-from htmllib import HTMLParser
-import os
-import re
-import formatter
-
-class HTMLTextView(wxFrame):
-    def __init__(self, parent, id, title='HTMLTextView', url=None):
-        wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
-                         wxSize(600,400))
-
-        EVT_CLOSE(self, self.OnCloseWindow)
-        self.mainmenu = wxMenuBar()
-
-        menu = wxMenu()
-        menu.Append(201, '&Open URL...', 'Open URL')
-        EVT_MENU(self, 201, self.OnFileOpen)
-        menu.Append(209, 'E&xit', 'Exit viewer')
-        EVT_MENU(self, 209, self.OnFileExit)
-
-        self.mainmenu.Append(menu, '&File')
-        self.SetMenuBar(self.mainmenu)
-        self.CreateStatusBar(1)
-
-        self.text = wxTextCtrl(self, -1, "", wxPyDefaultPosition,
-                               wxPyDefaultSize, wxTE_MULTILINE | wxTE_READONLY)
-
-        if (url):
-            self.OpenURL(url)
-
-    def logprint(self, x):
-        self.SetStatusText(x)
-
-    def OpenURL(self, url):
-        self.url = url
-        m = re.match('file:(\S+)\s*', url)
-        if m:
-            f = open(m.groups()[0],'r')
-        else:
-            m = re.match('http://([^/]+)(/\S*)\s*', url)
-            if m:
-                host = m.groups()[0]
-                path = m.groups()[1]
-            else:
-                m = re.match('http://(\S+)\s*', url)
-                if not m:
-                    # Invalid URL
-                    self.logprint("Invalid or unsupported URL: %s" % (url))
-                    return
-                host = m.groups()[0]
-                path = ''
-            f = RetrieveAsFile(host,path,self.logprint)
-        if not f:
-            self.logprint("Could not open %s" % (url))
-            return
-        self.logprint("Receiving data...")
-        data = f.read()
-        tmp = open('tmphtml.txt','w')
-        fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp))
-        p = HTMLParser(fmt)
-        self.logprint("Parsing data...")
-        p.feed(data)
-        p.close()
-        tmp.close()
-        tmp = open('tmphtml.txt', 'r')
-        self.text.SetValue(tmp.read())
-        self.SetTitle(url)
-        self.logprint(url)
-
-    def OnFileOpen(self, event):
-        dlg = wxTextEntryDialog(self, "Enter URL to open:", "")
-        if dlg.ShowModal() == wxID_OK:
-            url = dlg.GetValue()
-        else:
-            url = None
-        if url:
-            self.OpenURL(url)
-
-    def OnFileExit(self, event):
-        self.Close()
-
-    def OnCloseWindow(self, event):
-        self.Destroy()
-
-
-def ParseSlashdot(f):
-    art_sep = re.compile('%%\r?\n')
-    line_sep = re.compile('\r?\n')
-    data = f.read()
-    list = art_sep.split(data)
-    art_list = []
-    for i in range(1,len(list)-1):
-        art_list.append(line_sep.split(list[i]))
-    return art_list
-
-def myprint(x):
-    print x
-
-def RetrieveAsFile(host, path='', logprint = myprint):
-    try:
-        h = HTTP(host)
-    except:
-        logprint("Failed to create HTTP connection to %s... is the network available?" % (host))
-        return None
-    h.putrequest('GET',path)
-    h.putheader('Accept','text/html')
-    h.putheader('Accept','text/plain')
-    h.endheaders()
-    errcode, errmsg, headers = h.getreply()
-    if errcode != 200:
-        logprint("HTTP error code %d: %s" % (errcode, errmsg))
-        return None
-    f = h.getfile()
-#    f = open('/home/harm/ultramode.txt','r')
-    return f
-
-
-class AppStatusBar(wxStatusBar):
-    def __init__(self, parent):
-        wxStatusBar.__init__(self,parent, -1)
-        self.SetFieldsCount(2)
-        self.SetStatusWidths([-1, 100])
-        self.but = wxButton(self, 1001, "Refresh")
-        EVT_BUTTON(self, 1001, parent.OnViewRefresh)
-        EVT_SIZE(self, self.OnSize)
-        self.OnSize(None)
-
-    def logprint(self,x):
-        self.SetStatusText(x,0)
-
-    def OnSize(self, event):
-        rect = self.GetFieldRect(1)
-        self.but.SetPosition(wxPoint(rect.x+2, rect.y+2))
-        self.but.SetSize(wxSize(rect.width-4, rect.height-4))
-
-# This is a simple timer class to start a function after a short delay;
-class QuickTimer(wxTimer):
-    def __init__(self, func, wait=100):
-	wxTimer.__init__(self)
-	self.callback = func
-	self.Start(wait); # wait .1 second (.001 second doesn't work. why?)
-    def Notify(self):
-	self.Stop();
-	apply(self.callback, ());
-
-class AppFrame(wxFrame):
-    def __init__(self, parent, id, title):
-        wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
-                         wxSize(650, 250))
-
-	# if the window manager closes the window:
-	EVT_CLOSE(self, self.OnCloseWindow);
-
-	# Now Create the menu bar and items
-        self.mainmenu = wxMenuBar()
-
-        menu = wxMenu()
-        menu.Append(209, 'E&xit', 'Enough of this already!')
-        EVT_MENU(self, 209, self.OnFileExit)
-        self.mainmenu.Append(menu, '&File')
-        menu = wxMenu()
-        menu.Append(210, '&Refresh', 'Refresh headlines')
-        EVT_MENU(self, 210, self.OnViewRefresh)
-        menu.Append(211, '&Slashdot Index', 'View Slashdot index')
-        EVT_MENU(self, 211, self.OnViewIndex)
-        menu.Append(212, 'Selected &Article', 'View selected article')
-        EVT_MENU(self, 212, self.OnViewArticle)
-        self.mainmenu.Append(menu, '&View')
-        menu = wxMenu()
-        menu.Append(220, '&Internal', 'Use internal text browser',TRUE)
-        menu.Check(220, true)
-        self.UseInternal = 1;
-        EVT_MENU(self, 220, self.OnBrowserInternal)
-        menu.Append(222, '&Settings...', 'External browser Settings')
-        EVT_MENU(self, 222, self.OnBrowserSettings)
-        self.mainmenu.Append(menu, '&Browser')
-	menu = wxMenu()
-	menu.Append(230, '&About', 'Some documentation');
-	EVT_MENU(self, 230, self.OnAbout)
-	self.mainmenu.Append(menu, '&Help')
-
-        self.SetMenuBar(self.mainmenu)
-
-	if wxPlatform == '__WXGTK__':
-	    # I like lynx. Also Netscape 4.5 doesn't react to my cmdline opts
-	    self.BrowserSettings = "xterm -e lynx %s &"
-	elif wxPlatform == '__WXMSW__':
-	    # netscape 4.x likes to hang out here...
-	    self.BrowserSettings = '\\progra~1\\Netscape\\Communicator\\Program\\netscape.exe %s'
-	else:
-	    # a wild guess...
-	    self.BrowserSettings = 'netscape %s'
-
-	# A status bar to tell people what's happening
-	self.sb = AppStatusBar(self)
-        self.SetStatusBar(self.sb)
-
-        self.list = wxListCtrl(self, 1100, style=wxLC_REPORT)
-	self.list.InsertColumn(0, 'Subject')
-	self.list.InsertColumn(1, 'Date')
-	self.list.InsertColumn(2, 'Posted by')
-	self.list.InsertColumn(3, 'Comments')
-        self.list.SetColumnWidth(0, 300)
-        self.list.SetColumnWidth(1, 150)
-        self.list.SetColumnWidth(2, 100)
-        self.list.SetColumnWidth(3, 100)
-
-        EVT_LIST_ITEM_SELECTED(self, 1100, self.OnItemSelected)
-	EVT_LEFT_DCLICK(self.list, self.OnLeftDClick)
-
-	self.logprint("Connecting to slashdot... Please wait.")
-	# wxYield doesn't yet work here. That's why we use a timer
-	# to make sure that we see some GUI stuff before the slashdot
-	# file is transfered.
-	self.timer = QuickTimer(self.DoRefresh, 1000)
-
-    def logprint(self, x):
-        self.sb.logprint(x)
-
-    def OnFileExit(self, event):
-        self.Destroy()
-
-    def DoRefresh(self):
-        f = RetrieveAsFile('slashdot.org','/ultramode.txt',self.sb.logprint)
-        art_list = ParseSlashdot(f)
-        self.list.DeleteAllItems()
-        self.url = []
-        self.current = -1
-        i = 0;
-        for article in art_list:
-            self.list.InsertStringItem(i, article[0])
-            self.list.SetStringItem(i, 1, article[2])
-            self.list.SetStringItem(i, 2, article[3])
-            self.list.SetStringItem(i, 3, article[6])
-            self.url.append(article[1])
-            i = i + 1
-	self.logprint("File retrieved OK.")
-
-    def OnViewRefresh(self, event):
-	self.logprint("Connecting to slashdot... Please wait.");
-	wxYield()
-	self.DoRefresh()
-
-    def DoViewIndex(self):
-        if self.UseInternal:
-            self.view = HTMLTextView(self, -1, 'slashdot.org',
-                                     'http://slashdot.org')
-            self.view.Show(true)
-        else:
-            self.logprint(self.BrowserSettings % ('http://slashdot.org'))
-            #os.system(self.BrowserSettings % ('http://slashdot.org'))
-            wxExecute(self.BrowserSettings % ('http://slashdot.org'))
-	self.logprint("OK")
-
-    def OnViewIndex(self, event):
-	self.logprint("Starting browser... Please wait.")
-	wxYield()
-	self.DoViewIndex()
-
-    def DoViewArticle(self):
-        if self.current<0: return
-        url = self.url[self.current]
-        if self.UseInternal:
-            self.view = HTMLTextView(self, -1, url, url)
-            self.view.Show(true)
-        else:
-            self.logprint(self.BrowserSettings % (url))
-            os.system(self.BrowserSettings % (url))
-	self.logprint("OK")
-
-    def OnViewArticle(self, event):
-	self.logprint("Starting browser... Please wait.")
-	wxYield()
-	self.DoViewArticle()
-
-    def OnBrowserInternal(self, event):
-        if self.mainmenu.Checked(220):
-            self.UseInternal = 1
-        else:
-            self.UseInternal = 0
-
-    def OnBrowserSettings(self, event):
-        dlg = wxTextEntryDialog(self, "Enter command to view URL.\nUse %s as a placeholder for the URL.", "", self.BrowserSettings);
-        if dlg.ShowModal() == wxID_OK:
-            self.BrowserSettings = dlg.GetValue()
-
-    def OnAbout(self, event):
-	dlg = wxMessageDialog(self, __doc__, "wxSlash", wxOK | wxICON_INFORMATION)
-	dlg.ShowModal()
-
-    def OnItemSelected(self, event):
-        self.current = event.m_itemIndex
-        self.logprint("URL: %s" % (self.url[self.current]))
-
-    def OnLeftDClick(self, event):
-	(x,y) = event.Position();
-	# Actually, we should convert x,y to logical coords using
-	# a dc, but only for a wxScrolledWindow widget.
-	# Now wxGTK derives wxListCtrl from wxScrolledWindow,
-	# and wxMSW from wxControl... So that doesn't work.
-	#dc = wxClientDC(self.list)
-	##self.list.PrepareDC(dc)
-	#x = dc.DeviceToLogicalX( event.GetX() )
-	#y = dc.DeviceToLogicalY( event.GetY() )
-	id = self.list.HitTest(wxPoint(x,y))
-	#print "Double click at %d %d" % (x,y), id
-	# Okay, we got a double click. Let's assume it's the current selection
-	wxYield()
-	self.OnViewArticle(event)
-
-    def OnCloseWindow(self, event):
-        self.Destroy()
-
-
-#---------------------------------------------------------------------------
-# if running standalone
-
-if __name__ == '__main__':
-    class MyApp(wxApp):
-        def OnInit(self):
-            frame = AppFrame(NULL, -1, "Slashdot Breaking News")
-            frame.Show(true)
-            self.SetTopWindow(frame)
-            return true
-
-    app = MyApp(0)
-    app.MainLoop()
-
-
-
-#---------------------------------------------------------------------------
-# if running as part of the Demo Framework...
-
-def runTest(frame, nb, log):
-    win = AppFrame(NULL, -1, "Slashdot Breaking News")
-    frame.otherWin = win
-    win.Show(true)
-
-
-overview = __doc__
-
-
-#----------------------------------------------------------------------------
-
-