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/wxPython/py/CHANGES.txt

@@ -1,549 +0,0 @@
-
-0.9.1 (3/21/2003 to 5/2/2003)
------------------------------
-
-PyCrust is dead!  Long live Py!
-
-* Renamed ``PyCrust`` package to ``py``.
-* Moved code to wxPython's CVS repository.
-
-Fixed bug in ``introspect.py`` on introspecting objects occurring
-immediately after a secondary prompt, like this::
-
-    >>> l = [1, 2, 3]
-    >>> for n in range(3):
-    ...     l.  <-- failed to popup autocomplete list
-
-Added documentation files:
-
-* PyManual.txt
-* wxPythonManual.txt
-* wxPythonPackage.txt
-* wxPythonExamples.txt
-
-Added PyAlaMode and PyAlaCarte code editors.
-
-Major refactoring to support ``editor`` and ``shell`` from the same
-base.
-
-Renamed program files:
-
-* ``PyCrustApp.py`` to ``PyCrust.py``
-* ``PyFillingApp.py`` to ``PyFilling.py``
-* ``PyShellApp.py`` to ``PyShell.py``
-* ``wrap.py`` to ``PyWrap.py``
-
-Removed disabling of autocomplete for lists of 2000 items or more.
-The current implementation of wxSTC can now handle lists this big.
-
-Improved handling of ``sys.path`` to mimic the standard Python shell.
-
-
-0.9 (2/27/2003 to 3/20/2003)
-----------------------------
-
-Added fontIncrease, fontDecrease, fontDefault signals, receivers and
-keybindings::
-
-    Ctrl+]            Increase font size.
-    Ctrl+[            Decrease font size.
-    Ctrl+=            Default font size.
-
-Continued enhancement of the decorator capability to provide better
-documentation and docstrings for wxPython classes and functions.
-
-Introduced new tabbed interface:
-
-* Namespace
-* Calltip
-* Session
-* Dispatcher
-* wxPython Docs
-* wxSTC Docs
-
-``Filling.tree`` now expands tuples as well as lists.  (It should have
-done this all along, I just never noticed this omission before.)
-
-Added this True/False test to all modules::
-
-    try:
-        True
-    except NameError:
-        True = 1==1
-        False = 1==0
-
-Added ``wxd`` directory with decoration classes.
-
-
-0.8.2 (1/5/2003 to 2/26/2003)
------------------------------
-
-Wrapped ``sys.ps1``, ``sys.ps2``, and ``sys.ps3`` in ``str()``.
-(Thanks, Kieran Holland.)
-
-Fixed minor things found by PyChecker.
-
-Changed locals to use ``__main__.__dict__`` and added code to clean up
-the namespace, making it as close to the regular Python environment as
-possible.  This solves the problem of pickling and unpickling
-instances of classes defined in the shell.
-
-Made ``shell.PasteAndRun()`` a little more forgiving when it finds a
-ps2 prompt line with no trailing space, such when you copy code from a
-web page.
-
-Improved autocomplete behavior by adding these to shell::
-
-    self.AutoCompSetAutoHide(False)
-    self.AutoCompStops(' .,;:([)]}\'"\\<>%^&+-=*/|`')
-
-Added ``decor`` directory, ``decorator.py``, ``stcDecor.py``, and
-``stcConstants.py``.  These all serve the purpose of adding docstrings
-to existing wxPython classes, in particular the ``wxStyledTextCtrl``.
-
-Added ``wrap.py``, a command line utility for running a wxPython app
-with additional runtime-tools loaded, such as PyCrust (the only tool
-at this point).
-
-Flushed the clipboard Cut/Copy operations so that selections will
-exist in the clipboard even after PyCrust has been closed.
-
-Improved the suppression of docstrings for simple data types appearing
-in the namespace viewer.
-
-Better handling of autocompletion with numeric types; no
-autocompletion when typing a dot after an integer.  If the
-autocompletion is desired, type a space before the dot::
-
-    func = 3 .
-
-More Filling!!! The namespace tree is now dynamically updated.
-
-
-0.8.1 (12/20/2002 to 12/25/2002)
---------------------------------
-
-Improved keyboard handling with Autocomplete active.  You can now use
-Enter as well as Tab to select an item from the list.
-
-Disabled autocomplete for lists of 2000 items or more.  The current
-implementation of wxSTC can't handle lists this big.
-
-Changed ``filling`` to always display docstrings for objects.  This is
-useful for objects whose docstrings have been decorated, rather than
-coming directly from the source code.  (Hmmm.  Sounds like someone is
-doing some decorating.  I wonder where that would be helpful? <wink>)
-
-Fixed handling of icon.  Added ``images.py`` file.
-
-
-0.8 (10/29/2002 to 12/16/2002)
-------------------------------
-
-Added "help" to startup banner info.
-
-Made all ``wx`` and ``stc`` imports explicit.  No more ``import *``.
-
-Replaced use of the ``wx`` module's ``true`` and ``false`` with
-Python's ``True`` and ``False``.
-
-Changed ``introspect.getRoot()`` to use ``tokenize`` module.  This
-does a slightly better job than the previous parsing routine and the
-code is clearer.
-
-Improved handling of whitespace and empty types during introspection.
-
-Fixed cut/copy clipboard problem under Linux.  (Robin Dunn rocks!!!)
-
-Added shell.about() which works like this::
-
-    >>> shell.about()
-    PyCrust Version: 0.8
-    Shell Revision: 1.80
-    Interpreter Revision: 1.15
-    Python Version: 2.2.2
-    wxPython Version: 2.3.3.1
-    Platform: linux2
-
-Added copy plus and paste plus to shell menu.
-
-Moved shell menu from ``shell.py`` to ``shellmenu.py``.
-
-Added ``sys.stdin.readlines()`` support.
-
-Added ``time.sleep()`` in ``readline()`` and ``OnIdle()`` event
-handler to free up the CPU.
-
-
-0.7.2 (2/22/2002 to 8/27/2002)
-------------------------------
-
-Tweaked ``getAttributeNames()`` to pick up a few more attributes::
-
-    '__bases__', '__class__', '__dict__', '__name__', 'func_closure',
-    'func_code', 'func_defaults', 'func_dict', 'func_doc',
-    'func_globals', 'func_name'
-
-Added a tests directory and unit tests.
-
-Improved support for empty types in the shell: ``[]``, ``()`` and
-``{}`` as far as when call tips and autocompletion are available.
-
-Added support for the other triple string - ``''''''``.
-
-Refactored ``introspect.py`` to improve testability.
-
-Improved call tips for unbound methods by leaving the "self"
-parameter, since unbound methods require an instance be passed.
-
-Fixed call tip bug where a tip was displayed when a "(" was typed
-after an object that wasn't callable.
-
-Fixed ``getAllAttributeNames`` when ``str(object)`` fails.
-
-Added brace highlighting.  (Thank you, Kevin Altis.)
-
-Fixed problem displaying unicode objects in ``PyFilling``.
-
-Changed how ``filling.py`` checks for expandable objects.  Lists are
-now expandable objects.
-
-Made the key handling more robust when there is an active text
-selection that includes text prior to the last primary prompt.  Thanks
-to Raul Cota for pointing this out.
-
-Fixed wxSTC problem with brace highlighting and non-us keyboards.
-(Thank you for the patch, Jean-Michel Fauth.)
-
-Added ``busy = wxBusyCursor()`` to key points in ``shell`` and
-``filling``.
-
-Added ``OnCloseWindow`` handler to ``ShellFrame`` and ``CrustFrame``.
-
-Default to ``SetWrapMode(1)`` for shell and namespace viewer.
-
-Added ``shell.wrap()`` and ``shell.zoom()``.
-
-Added autoCompleteKeys hooks for Raul Cota.
-
-Cleaned up various little key handling bugs.
-
-Changed input methods to get values from shell, rather than dialog
-boxes.  Renamed ``readIn`` to ``readline`` and ``readRaw`` to
-``raw_input``.
-
-
-0.7.1 (12/12/2001 to 2/21/2002)
--------------------------------
-
-Fixed ``OnChar()`` issues effecting European keyboards, as reported by
-Jean-Michel Fauth.
-
-Fixed ``introspect.py`` issue with xmlrpc objects reported by Kevin
-Altis.
-
-Fixed some introspect/PyFilling issues with regard to Python 2.2.
-
-Fixed font background color as reported by Keith J. Farmer.  (Thanks)
-
-Fixed problem with call tips and autocompletion inside multiline
-commands as report by Kevin Altis.
-
-Improved ``OnKeyDown`` handling of cut/copy/paste operations based on
-feedback from Syver Enstad.  (Thanks)
-
-Added a ``shell.help()`` method to display some help info.
-
-Changed sort of items in the namespace viewer to case insensitive.
-
-Changed ``attributes.sort(lambda x, y: cmp(x.upper(), y.upper()))`` in
-advance of an upcoming fix to an autocompletion matching bug in wxSTC.
-
-Improved support for ZODB by allowing namespace drilldown into BTrees.
-
-Added ``shell.PasteAndRun()`` to support pasting multiple commands into
-the shell from the clipboard.  Ctrl+Shift+V or v.
-
-Enter now always processes a command (or copies down a previous one.)
-To insert a line break, press Ctrl+Enter.
-
-Escape key clears the current, unexecuted command.
-
-History retrieval changed to replace current command.  Added new keys
-to insert from history - Shift+Up and Shift+Down.
-
-Better call tips on objects with ``__call__`` methods.
-
-Improved call tip positioning calculation.
-
-
-0.7 (10/15/2001 to 12/11/2001)
-------------------------------
-
-Changed how command history retrieval functions work.  Added Alt-P,
-Alt-N as keybindings for Retrieve-Previous, Retrieve-Next.
-
-Added full support for multi-line commands, similar to IDLE.
-
-Changed ``introspect.getAttributeNames()`` to do a case insensitive
-sort.
-
-Changed Cut/Copy/Paste to deal with prompts intelligently.  Cut and
-Copy remove all prompts.  Paste can handle prompted or not-prompted
-text.
-
-Added ``CopyWithPrompts()`` method attached to Ctrl-Shift-C for those
-times when you really do want all the prompts left intact.
-
-Improved handling of the shell's read-only zone.
-
-Changed ``CrustFrame.__init__`` parameter spec to include all
-parameters allowed by a ``wxFrame``.
-
-Changed ``FillingText`` to be read-only.
-
-Renamed ``PyCrust.py`` to ``PyCrustApp.py`` to eliminate
-package/module name conflicts that kept you from doing ``from PyCrust
-import shell`` inside files located in the ``PyCrust`` directory.
-
-Renamed ``PyFilling.py`` to ``PyFillingApp.py`` and ``PyShell.py`` to
-``PyShellApp.py`` to maintain consistency.
-
-Removed the ``__date__`` property from all modules.
-
-Fixed bug in ``introspect.getCallTip()``, reported by Kevin Altis.
-
-
-0.6.1 (9/19/2001 to 10/12/2001)
--------------------------------
-
-Changed ``Shell.run()`` to always position to the end of existing
-text, as suggested by Raul Cota.
-
-Changed ``introspect.getAllAttributeNames()`` to break circular
-references in ``object.__class__``, which occurs in Zope/ZODB
-extension classes.
-
-Changed ``filling.FillingTree.getChildren()`` to introspect extension
-classes.
-
-Fixed minor bugs in ``introspect.getCallTip()`` that were interfering
-with call tips for Zope/ZODB extension class methods.
-
-In preparation for wxPython 2.3.2, added code to fix a font sizing
-problem.  Versions of wxPython prior to 2.3.2 had a sizing bug on Win
-platform where the font was 2 points larger than what was specified.
-
-Added a hack to ``introspect.getAllAttributeNames()`` to "wake up"
-ZODB objects that are asleep - in a "ghost" state.  Otherwise it
-returns incomplete info.
-
-
-0.6 (8/21/2001 to 9/12/2001)
-----------------------------
-
-Added ``PyFilling.py`` and ``filling.py``.
-
-``PyShell.py`` and ``PyFilling.py`` can now be run standalone, as well
-as ``PyCrust.py``.
-
-Added ``crust.py`` and moved some code from ``PyCrust.py`` to it.
-
-Added command history retrieval features submitted by Richie Hindle.
-
-Changed ``shell.write()`` to replace line endings with OS-specific
-endings.  Changed ``shell.py`` and ``interpreter.py`` to use
-``os.linesep`` in strings having hardcoded line endings.
-
-Added ``shell.redirectStdin()``, ``shell.redirectStdout()`` and
-``shell.redirectStderr()`` to allow the surrounding app to toggle
-requests that the specified ``sys.std*`` be redirected to the shell.
-These can also be run from within the shell itself, of course.
-
-The shell now adds the current working directory "." to the search
-path::
-
-    sys.path.insert(0, os.curdir)
-
-Added support for distutils installations.
-
-
-0.5.4 (8/17/2001 to 8/20/2001)
-------------------------------
-
-Changed default font size under Linux to::
-
-    'size'   : 12,
-    'lnsize' : 10,
-
-Changed ``Shell`` to expect a parameter referencing an Interpreter
-class, rather than an intepreter instance, to facilitate subclassing
-of Interpreter, which effectively broke when the Editor class was
-eliminated.
-
-Fixed ``PyCrustAlaCarte.py``, which had been broken by previous
-changes.
-
-Created ``InterpreterAlaCarte`` class as an example for use in the
-demo.
-
-Split ``PyCrust.py`` into ``PyCrust.py`` and ``PyShell.py`` in
-anticipation of ``PyFilling.py``.
-
-
-0.5.3 (8/16/2001)
------------------
-
-Added patch to ``PyCrust.py`` to fix wxPython bug::
-
-    wxID_SELECTALL = NewId() # This *should* be defined by wxPython.
-
-
-0.5.2 (8/14/2001 to 8/15/2001)
-------------------------------
-
-Shortened module names by dropping "PyCrust" as a prefix.
-
-Changed ``version`` to ``VERSION`` in ``version`` module.
-
-Added Options menu to PyCrust application.
-
-Eliminated the Editor class (and editor module) by merging with Shell.
-This means that Shell "is a" wxStyledTextCtrl rather than "has a".
-There just wasn't enough non-gui code to justify the separation.
-Plus, Shell will be much easier for gui toolkits/designers to deal
-with now.
-
-
-0.5.1 (8/10/2001 to 8/14/2001)
-------------------------------
-
-Added ``introspect`` module.
-
-Moved some functionality from ``PyCrustInterp`` to ``introspect``.
-
-Changed ``introspect.getRoot()`` to no longer remove whitespace from
-the command.  This was a remnant of a previous approach that, when
-left as part of the current approach, turned out to be a really bad
-thing.
-
-Changed ``introspect.getRoot()`` to allow commands of ``''``, ``""``,
-``""""""``, ``[]``, ``()``, and ``{}`` to pass through.  This allows
-you to type them, followed by a dot, and get autocomplete options on
-them.
-
-Changed ``introspect.getRoot()`` to identify some situations where
-strings shouldn't be considered roots.  For example::
-
-    >>> import PyCrust  # To illustrate the potential problem.
-    >>> len('PyCrust.py')
-
-Typing the dot at the end of "PyCrust" in the second line above should
-NOT result in an autocompletion list because "PyCrust" is part of a
-string in this context, not a reference to the PyCrust module object.
-Similar reasoning applies to call tips.  For example::
-
-    >>> len('dir(')
-
-Typing the left paren at the end of "dir" should NOT result in a call
-tip.
-
-Both features now behave properly in the examples given.  However,
-there is still the case where whitespace precedes the potential root
-and that is NOT handled properly.  For example::
-
-    >>> len('this is a dir(')
-
-and::
-
-    >>> len('This is PyCrust.py')
-
-More code needs to be written to handle more complex situations.
-
-Added ``locals=None`` parameter to ``Shell.__init__()``.
-
-Added support for magic attribute retrieval.  Users can change this
-with::
-
-    >>> shell.editor.autoCompleteIncludeMagic = 0
-
-Added the ability to set filters on auto completion to exclude
-attributes prefixed with a single or double underscore.  Users can
-exclude one or the other or both with::
-
-    >>> shell.editor.autoCompleteExcludeSingle = 1
-    >>> shell.editor.autoCompleteExcludeDouble = 1
-
-
-0.5 (8/8/2001)
---------------
-
-Mostly just a final version change before creating a release.
-
-
-0.4 (8/4/2001 to 8/7/2001)
---------------------------
-
-Changed version/revision handling.
-
-Fixed bugs.
-
-
-0.3 (8/2/2001 to 8/3/2001)
---------------------------
-
-Removed lots of cruft.
-
-Added lots of docstrings.
-
-Imported to CVS repository at SourceForge.
-
-Added call tips.
-
-
-0.2 (7/30/2001 to 8/2/2001)
----------------------------
-
-Renamed several files.
-
-Added command autocompletion.
-
-Added menus to PyCrust.py: File, Edit and Help.
-
-Added sample applications: ``PyCrustAlaCarte.py``,
-``PyCrustAlaMode.py``, and ``PyCrustMinimus.py``.
-
-
-0.1 (7/1/2001 to 7/19/2001)
----------------------------
-
-Added basic syntax coloring much like Boa.
-
-Added read-only logging much like IDLE.
-
-Can retrieve a previous command by putting the cursor back on that
-line and hitting enter.
-
-Stdin and raw_input operate properly so you can now do ``help()`` and
-``license()`` without hanging.
-
-Redefined "quit", "exit", and "close" to display a better-than-nothing
-response.
-
-Home key honors the prompt.
-
-Created SourceForge account, but nothing was posted.
-
-
-In the beginning, there was pie... (7/1/2001)
----------------------------------------------
-
-Blame it all on IDLE, Boa and PythonWin.  I was using all three, got
-frustrated with their dissimilarities, and began to let everyone know
-how I felt.  At the same time, Scintilla looked like an interesting
-tool to build a shell around.  And while I didn't receive much in the
-way of positive feedback, let alone encouragement, I just couldn't let
-go of the idea of a Scintilla-based Python shell.  Then the PythonCard
-project got to the point where they were talking about including a
-shell in their development environment.  That was all the incentive I
-needed.  PyCrust had to happen...

wxPython/wxPython/py/PyAlaCarte.py

@@ -1,43 +0,0 @@
-"""PyAlaCarte is a simple programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-import os
-import sys
-
-import editor
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-class App(wx.wxApp):
-    """PyAlaCarte standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.wxApp.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.wxInitAllImageHandlers()
-        self.frame = editor.EditorFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    if not filename and len(sys.argv) > 1:
-        filename = sys.argv[1]
-    if filename:
-        filename = os.path.realpath(filename)
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyAlaMode.py

@@ -1,43 +0,0 @@
-"""PyAlaMode is a programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-import os
-import sys
-
-import editor
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-class App(wx.wxApp):
-    """PyAlaMode standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.wxApp.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.wxInitAllImageHandlers()
-        self.frame = editor.EditorNotebookFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    if not filename and len(sys.argv) > 1:
-        filename = sys.argv[1]
-    if filename:
-        filename = os.path.realpath(filename)
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyAlaModeTest.py

@@ -1,42 +0,0 @@
-"""PyAlaModeTest is a programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-import os
-import sys
-
-import editor
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-class App(wx.wxApp):
-    """PyAlaModeTest standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.wxApp.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.wxInitAllImageHandlers()
-        self.frame = editor.EditorShellNotebookFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    filename = None
-    if len(sys.argv) > 1:
-        filename = os.path.realpath(sys.argv[1])
-    main(filename)

wxPython/wxPython/py/PyCrust.py

@@ -1,78 +0,0 @@
-"""PyCrust is a python shell and namespace browser application."""
-
-# The next two lines, and the other code below that makes use of
-# ``__main__`` and ``original``, serve the purpose of cleaning up the
-# main namespace to look as much as possible like the regular Python
-# shell environment.
-import __main__
-original = __main__.__dict__.keys()
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class App(wx.wxApp):
-    """PyCrust standalone application."""
-
-    def OnInit(self):
-        from wxPython import wx
-        wx.wxInitAllImageHandlers()
-        locals = __main__.__dict__
-        from crust import CrustFrame
-        self.frame = CrustFrame(locals=locals)
-        self.frame.SetSize((800, 600))
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-'''
-The main() function needs to handle being imported, such as with the
-pycrust script that wxPython installs:
-
-    #!/usr/bin/env python
-
-    from wx.py.PyCrust import main
-    main()
-'''
-
-def main():
-    """The main function for the PyCrust program."""
-    # Cleanup the main namespace, leaving the App class.
-    import __main__
-    md = __main__.__dict__
-    keepers = original
-    keepers.append('App')
-    for key in md.keys():
-        if key not in keepers:
-            del md[key]
-    # Create an application instance.
-    app = App(0)
-    # Mimic the contents of the standard Python shell's sys.path.
-    import sys
-    if sys.path[0]:
-        sys.path[0] = ''
-    # Add the application object to the sys module's namespace.
-    # This allows a shell user to do:
-    # >>> import sys
-    # >>> sys.app.whatever
-    sys.app = app
-    del sys
-    # Cleanup the main namespace some more.
-    if md.has_key('App') and md['App'] is App:
-        del md['App']
-    if md.has_key('__main__') and md['__main__'] is __main__:
-        del md['__main__']
-    # Start the wxPython event loop.
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyFilling.py

@@ -1,44 +0,0 @@
-"""PyFilling is a python namespace inspection application."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-# We use this object to get more introspection when run standalone.
-app = None
-
-import filling
-
-# These are imported just to have something interesting to inspect.
-import crust
-import interpreter
-import introspect
-import pseudo
-import shell
-
-import sys
-from wxPython import wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class App(filling.App):
-    def OnInit(self):
-        filling.App.OnInit(self)
-        self.root = self.fillingFrame.filling.tree.root
-        return True
-
-def main():
-    """Create and run the application."""
-    global app
-    app = App(0)
-    app.fillingFrame.filling.tree.Expand(app.root)
-    app.MainLoop()
-
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyShell.py

@@ -1,79 +0,0 @@
-"""PyShell is a python shell application."""
-
-# The next two lines, and the other code below that makes use of
-# ``__main__`` and ``original``, serve the purpose of cleaning up the
-# main namespace to look as much as possible like the regular Python
-# shell environment.
-import __main__
-original = __main__.__dict__.keys()
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class App(wx.wxApp):
-    """PyShell standalone application."""
-
-    def OnInit(self):
-        from wxPython import wx
-        wx.wxInitAllImageHandlers()
-        locals = __main__.__dict__
-        from shell import ShellFrame
-        self.frame = ShellFrame(locals=locals)
-        self.frame.SetSize((750, 525))
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        self.frame.shell.SetFocus()
-        return True
-
-'''
-The main() function needs to handle being imported, such as with the
-pyshell script that wxPython installs:
-
-    #!/usr/bin/env python
-
-    from wx.py.PyShell import main
-    main()
-'''
-
-def main():
-    """The main function for the PyShell program."""
-    # Cleanup the main namespace, leaving the App class.
-    import __main__
-    md = __main__.__dict__
-    keepers = original
-    keepers.append('App')
-    for key in md.keys():
-        if key not in keepers:
-            del md[key]
-    # Create an application instance.
-    app = App(0)
-    # Cleanup the main namespace some more.
-    if md.has_key('App') and md['App'] is App:
-        del md['App']
-    if md.has_key('__main__') and md['__main__'] is __main__:
-        del md['__main__']
-    # Mimic the contents of the standard Python shell's sys.path.
-    import sys
-    if sys.path[0]:
-        sys.path[0] = ''
-    # Add the application object to the sys module's namespace.
-    # This allows a shell user to do:
-    # >>> import sys
-    # >>> sys.app.whatever
-    sys.app = app
-    del sys
-    # Start the wxPython event loop.
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyWrap.py

@@ -1,56 +0,0 @@
-"""PyWrap is a command line utility that runs a wxPython program with
-additional runtime-tools, such as PyCrust."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-import sys
-from wxPython import wx
-from crust import CrustFrame as Frame
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-def wrap(app):
-    wx.wxInitAllImageHandlers()
-    frame = Frame()
-    frame.SetSize((750, 525))
-    frame.Show(True)
-    frame.shell.interp.locals['app'] = app
-    app.MainLoop()
-
-
-def main(modulename=None):
-    sys.path.insert(0, os.curdir)
-    if not modulename:
-        if len(sys.argv) < 2:
-            print "Please specify a module name."
-            raise SystemExit
-        modulename = sys.argv[1]
-        if modulename.endswith('.py'):
-            modulename = modulename[:-3]
-    module = __import__(modulename)
-    # Find the App class.
-    App = None
-    d = module.__dict__
-    for item in d.keys():
-        try:
-            if issubclass(d[item], wx.wxApp):
-                App = d[item]
-        except (NameError, TypeError):
-            pass
-    if App is None:
-        print "No App class found."
-        raise SystemExit
-    app = App()
-    wrap(app)
-
-
-if __name__ == '__main__':
-    main(sys.argv)

wxPython/wxPython/py/README.txt

@@ -1,79 +0,0 @@
-=====================================
- PyCrust - The Flakiest Python Shell
-=====================================
-
-Half-baked by Patrick K. O'Brien (pobrien@orbtech.com)
-
-Orbtech - "Your source for Python programming expertise."
-Sample all our half-baked Python goods at www.orbtech.com.
-
-
-What is PyCrust?
-----------------
-
-PyCrust is an interactive Python environment written in Python.
-PyCrust components can run standalone or be integrated into other
-development environments and/or other Python applications.
-
-PyCrust comes with an interactive Python shell (PyShell), an
-interactive namespace/object tree control (PyFilling) and an
-integrated, split-window combination of the two (PyCrust).
-
-
-What is PyCrust good for?
--------------------------
-
-Have you ever tried to bake a pie without one? Well, you shouldn't
-build a Python program without a PyCrust either.
-
-
-What else do I need to use PyCrust?
------------------------------------
-
-PyCrust requires Python 2.1.3 or later, and wxPython 2.4 or later.
-PyCrust uses wxPython and the Scintilla wrapper (wxStyledTextCtrl).
-Python is available at http://www.python.org/.  wxPython is available
-at http://www.wxpython.org/.
-
-
-Where can I get the latest version of PyCrust?
-----------------------------------------------
-
-The latest production version ships with wxPython.  The latest
-developer version is available in CVS at:
-http://sourceforge.net/cvs/?group_id=31263
-
-
-Where is the PyCrust project hosted?
-------------------------------------
-
-At SourceForge, of course. The SourceForge summary page:
-http://sourceforge.net/projects/pycrust/
-
-
-I found a bug in PyCrust, what do I do with it?
------------------------------------------------
-
-You can send it to me at pobrien@orbtech.com.
-
-
-I want a new feature added to PyCrust. Will you do it?
-------------------------------------------------------
-
-Flattery and money will get you anything. Short of that, you can send
-me a request and I'll see what I can do.
-
-
-Does PyCrust have a mailing list full of wonderful people?
-----------------------------------------------------------
-
-As a matter of fact, we do. Join the PyCrust mailing lists at:
-http://sourceforge.net/mail/?group_id=31263
-
-
-What is the CVS information for this README file?
--------------------------------------------------
-
-$Date$
-$Revision$
-$Id$

wxPython/wxPython/py/__init__.py

@@ -1,20 +0,0 @@
-"""Python package."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import buffer
-import crust
-import dispatcher
-import document
-import editor
-import editwindow
-import filling
-import frame
-import images
-import interpreter
-import introspect
-import pseudo
-import shell
-import version

wxPython/wxPython/py/buffer.py

@@ -1,146 +0,0 @@
-"""Buffer class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-from interpreter import Interpreter
-import imp
-import os
-import sys
-
-import document
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Buffer:
-    """Buffer class."""
-
-    id = 0
-
-    def __init__(self, filename=None):
-        """Create a Buffer instance."""
-        Buffer.id += 1
-        self.id = Buffer.id
-        self.interp = Interpreter(locals={})
-        self.name = ''
-        self.editors = {}
-        self.editor = None
-        self.modules = sys.modules.keys()
-        self.syspath = sys.path[:]
-        while True:
-            try:
-                self.syspath.remove('')
-            except ValueError:
-                break
-        while True:
-            try:
-                self.syspath.remove('.')
-            except ValueError:
-                break
-        self.open(filename)
-
-    def addEditor(self, editor):
-        """Add an editor."""
-        self.editor = editor
-        self.editors[editor.id] = editor
-
-    def hasChanged(self):
-        """Return True if text in editor has changed since last save."""
-        if self.editor:
-            return self.editor.hasChanged()
-        else:
-            return False
-
-    def new(self, filepath):
-        """New empty buffer."""
-        if not filepath:
-            return
-        if os.path.exists(filepath):
-            self.confirmed = self.overwriteConfirm(filepath)
-        else:
-            self.confirmed = True
-
-    def open(self, filename):
-        """Open file into buffer."""
-        self.doc = document.Document(filename)
-        self.name = self.doc.filename or ('Untitled:' + str(self.id))
-        self.modulename = self.doc.filebase
-        # XXX This should really make sure filedir is first item in syspath.
-        # XXX Or maybe this should be moved to the update namespace method.
-        if self.doc.filedir and self.doc.filedir not in self.syspath:
-            # To create the proper context for updateNamespace.
-            self.syspath.insert(0, self.doc.filedir)
-        if self.doc.filepath and os.path.exists(self.doc.filepath):
-            self.confirmed = True
-        if self.editor:
-            text = self.doc.read()
-            self.editor._setBuffer(buffer=self, text=text)
-
-    def overwriteConfirm(filepath):
-        """Confirm overwriting an existing file."""
-        return False
-
-    def save(self):
-        """Save buffer."""
-        filepath = self.doc.filepath
-        if not filepath:
-            return  # XXX Get filename
-        if not os.path.exists(filepath):
-            self.confirmed = True
-        if not self.confirmed:
-            self.confirmed = self.overwriteConfirm(filepath)
-        if self.confirmed:
-            self.doc.write(self.editor.getText())
-            if self.editor:
-                self.editor.setSavePoint()
-
-    def saveAs(self, filename):
-        """Save buffer."""
-        self.doc = document.Document(filename)
-        self.name = self.doc.filename
-        self.modulename = self.doc.filebase
-        self.save()
-
-    def updateNamespace(self):
-        """Update the namespace for autocompletion and calltips.
-
-        Return True if updated, False if there was an error."""
-        if not self.interp or not hasattr(self.editor, 'getText'):
-            return False
-        syspath = sys.path
-        sys.path = self.syspath
-        text = self.editor.getText()
-        text = text.replace('\r\n', '\n')
-        text = text.replace('\r', '\n')
-        name = self.modulename or self.name
-        module = imp.new_module(name)
-        newspace = module.__dict__.copy()
-        try:
-            try:
-                code = compile(text, name, 'exec')
-            except:
-                raise
-#                return False
-            try:
-                exec code in newspace
-            except:
-                raise
-#                return False
-            else:
-                # No problems, so update the namespace.
-                self.interp.locals.clear()
-                self.interp.locals.update(newspace)
-                return True
-        finally:
-            sys.path = syspath
-            for m in sys.modules.keys():
-                if m not in self.modules:
-                    del sys.modules[m]

wxPython/wxPython/py/crust.py

@@ -1,182 +0,0 @@
-"""PyCrust Crust combines the shell and filling into one control."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-import os
-import sys
-
-import dispatcher
-from filling import Filling
-import frame
-from shell import Shell
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Crust(wx.wxSplitterWindow):
-    """PyCrust Crust based on wxSplitterWindow."""
-
-    name = 'PyCrust Crust'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.wxDefaultPosition, 
-                 size=wx.wxDefaultSize, style=wx.wxSP_3D,
-                 name='Crust Window', rootObject=None, rootLabel=None,
-                 rootIsNamespace=True, intro='', locals=None, 
-                 InterpClass=None, *args, **kwds):
-        """Create a PyCrust Crust instance."""
-        wx.wxSplitterWindow.__init__(self, parent, id, pos, size, style, name)
-        self.shell = Shell(parent=self, introText=intro, 
-                           locals=locals, InterpClass=InterpClass, 
-                           *args, **kwds)
-        self.editor = self.shell
-        if rootObject is None:
-            rootObject = self.shell.interp.locals
-        self.notebook = wx.wxNotebook(parent=self, id=-1)
-        self.shell.interp.locals['notebook'] = self.notebook
-        self.filling = Filling(parent=self.notebook, 
-                               rootObject=rootObject, 
-                               rootLabel=rootLabel, 
-                               rootIsNamespace=rootIsNamespace)
-        # Add 'filling' to the interpreter's locals.
-        self.shell.interp.locals['filling'] = self.filling
-        self.notebook.AddPage(page=self.filling, text='Namespace', select=True)
-        self.calltip = Calltip(parent=self.notebook)
-        self.notebook.AddPage(page=self.calltip, text='Calltip')
-        self.sessionlisting = SessionListing(parent=self.notebook)
-        self.notebook.AddPage(page=self.sessionlisting, text='Session')
-        self.dispatcherlisting = DispatcherListing(parent=self.notebook)
-        self.notebook.AddPage(page=self.dispatcherlisting, text='Dispatcher')
-        from wxd import wx_
-        self.wxdocs = Filling(parent=self.notebook, 
-                              rootObject=wx_,
-                              rootLabel='wx', 
-                              rootIsNamespace=False,
-                              static=True)
-        self.notebook.AddPage(page=self.wxdocs, text='wxPython Docs')
-        from wxd import stc_
-        self.stcdocs = Filling(parent=self.notebook, 
-                               rootObject=stc_.StyledTextCtrl,
-                               rootLabel='StyledTextCtrl', 
-                               rootIsNamespace=False,
-                               static=True)
-        self.notebook.AddPage(page=self.stcdocs, text='StyledTextCtrl Docs')
-        self.SplitHorizontally(self.shell, self.notebook, 300)
-        self.SetMinimumPaneSize(1)
-
-
-class Calltip(wx.wxTextCtrl):
-    """Text control containing the most recent shell calltip."""
-
-    def __init__(self, parent=None, id=-1):
-        style = wx.wxTE_MULTILINE | wx.wxTE_READONLY | wx.wxTE_RICH2
-        wx.wxTextCtrl.__init__(self, parent=parent, id=id, style=style)
-        self.SetBackgroundColour(wx.wxColour(255, 255, 232))
-        dispatcher.connect(receiver=self.display, signal='Shell.calltip')
-
-    def display(self, calltip):
-        """Receiver for Shell.calltip signal."""
-        self.SetValue(calltip)
-
-
-class SessionListing(wx.wxTextCtrl):
-    """Text control containing all commands for session."""
-
-    def __init__(self, parent=None, id=-1):
-        style = wx.wxTE_MULTILINE | wx.wxTE_READONLY | \
-                wx.wxTE_RICH2 | wx.wxTE_DONTWRAP
-        wx.wxTextCtrl.__init__(self, parent=parent, id=id, style=style)
-        dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        if command and not more:
-            self.SetInsertionPointEnd()
-            start, end = self.GetSelection()
-            if start != end:
-                self.SetSelection(0, 0)
-            self.AppendText(command + '\n')
-
-
-class DispatcherListing(wx.wxTextCtrl):
-    """Text control containing all dispatches for session."""
-
-    def __init__(self, parent=None, id=-1):
-        style = wx.wxTE_MULTILINE | wx.wxTE_READONLY | \
-                wx.wxTE_RICH2 | wx.wxTE_DONTWRAP
-        wx.wxTextCtrl.__init__(self, parent=parent, id=id, style=style)
-        dispatcher.connect(receiver=self.spy)
-
-    def spy(self, signal, sender):
-        """Receiver for Any signal from Any sender."""
-        text = '%r from %s' % (signal, sender)
-        self.SetInsertionPointEnd()
-        start, end = self.GetSelection()
-        if start != end:
-            self.SetSelection(0, 0)
-        self.AppendText(text + '\n')
-
-
-class CrustFrame(frame.Frame):
-    """Frame containing all the PyCrust components."""
-
-    name = 'PyCrust Frame'
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='PyCrust',
-                 pos=wx.wxDefaultPosition, size=wx.wxDefaultSize,
-                 style=wx.wxDEFAULT_FRAME_STYLE,
-                 rootObject=None, rootLabel=None, rootIsNamespace=True,
-                 locals=None, InterpClass=None, *args, **kwds):
-        """Create a PyCrust CrustFrame instance."""
-        frame.Frame.__init__(self, parent, id, title, pos, size, style)
-        intro = 'PyCrust %s - The Flakiest Python Shell' % VERSION
-        intro += '\nSponsored by Orbtech - '
-        intro += 'Your source for Python programming expertise.'
-        self.SetStatusText(intro.replace('\n', ', '))
-        self.crust = Crust(parent=self, intro=intro,
-                           rootObject=rootObject,
-                           rootLabel=rootLabel,
-                           rootIsNamespace=rootIsNamespace,
-                           locals=locals,
-                           InterpClass=InterpClass, *args, **kwds)
-        self.shell = self.crust.shell
-        # Override the filling so that status messages go to the status bar.
-        self.crust.filling.tree.setStatusText = self.SetStatusText
-        # Override the shell so that status messages go to the status bar.
-        self.shell.setStatusText = self.SetStatusText
-        # Fix a problem with the sash shrinking to nothing.
-        self.crust.filling.SetSashPosition(200)
-        # Set focus to the shell editor.
-        self.shell.SetFocus()
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        self.crust.shell.destroy()
-        self.Destroy()
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyCrust'
-        text = 'PyCrust %s\n\n' % VERSION + \
-               'Yet another Python shell, only flakier.\n\n' + \
-               'Half-baked by Patrick K. O\'Brien,\n' + \
-               'the other half is still in the oven.\n\n' + \
-               'Shell Revision: %s\n' % self.shell.revision + \
-               'Interpreter Revision: %s\n\n' % self.shell.interp.revision + \
-               'Python Version: %s\n' % sys.version.split()[0] + \
-               'wxPython Version: %s\n' % wx.__version__ + \
-               'Platform: %s\n' % sys.platform
-        dialog = wx.wxMessageDialog(self, text, title,
-                                    wx.wxOK | wx.wxICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()

wxPython/wxPython/py/dispatcher.py

@@ -1,266 +0,0 @@
-"""Provides global signal dispatching services."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import exceptions
-import types
-import weakref
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class DispatcherError(exceptions.Exception):
-    def __init__(self, args=None):
-        self.args = args
-
-
-class Parameter:
-    """Used to represent default parameter values."""
-    def __repr__(self):
-        return self.__class__.__name__
-
-class Any(Parameter): pass
-Any = Any()
-
-class Anonymous(Parameter): pass
-Anonymous = Anonymous()
-
-
-connections = {}
-senders = {}
-_boundMethods = weakref.WeakKeyDictionary()
-
-
-def connect(receiver, signal=Any, sender=Any, weak=True):
-    """Connect receiver to sender for signal.
-    
-    If sender is Any, receiver will receive signal from any sender.
-    If signal is Any, receiver will receive any signal from sender.
-    If sender is None, receiver will receive signal from Anonymous.
-    If signal is Any and sender is None, receiver will receive any 
-        signal from Anonymous.
-    If signal is Any and sender is Any, receiver will receive any 
-        signal from any sender.
-    If weak is true, weak references will be used."""
-    if signal is None:
-        raise DispatcherError, 'signal cannot be None'
-    if weak:
-        receiver = safeRef(receiver)
-    senderkey = id(sender)
-    signals = {}
-    if connections.has_key(senderkey):
-        signals = connections[senderkey]
-    else:
-        connections[senderkey] = signals
-        # Keep track of senders for cleanup.
-        if sender not in (None, Any):
-            def remove(object, senderkey=senderkey):
-                _removeSender(senderkey=senderkey)
-            # Skip objects that can not be weakly referenced, which means
-            # they won't be automatically cleaned up, but that's too bad.
-            try:
-                weakSender = weakref.ref(sender, remove)
-                senders[senderkey] = weakSender
-            except:
-                pass
-    receivers = []
-    if signals.has_key(signal):
-        receivers = signals[signal]
-    else:
-        signals[signal] = receivers
-    try:
-        receivers.remove(receiver)
-    except ValueError:
-        pass
-    receivers.append(receiver)
-
-def disconnect(receiver, signal=Any, sender=Any, weak=True):
-    """Disconnect receiver from sender for signal.
-    
-    Disconnecting is not required. The use of disconnect is the same as for
-    connect, only in reverse. Think of it as undoing a previous connection."""
-    if signal is None:
-        raise DispatcherError, 'signal cannot be None'
-    if weak:
-        receiver = safeRef(receiver)
-    senderkey = id(sender)
-    try:
-        receivers = connections[senderkey][signal]
-    except KeyError:
-        raise DispatcherError, \
-              'No receivers for signal %r from sender %s' % (signal, sender)
-    try:
-        receivers.remove(receiver)
-    except ValueError:
-        raise DispatcherError, \
-              'No connection to receiver %s for signal %r from sender %s' % \
-              (receiver, signal, sender)
-    _cleanupConnections(senderkey, signal)
-
-def send(signal, sender=Anonymous, **kwds):
-    """Send signal from sender to all connected receivers.
-    
-    Return a list of tuple pairs [(receiver, response), ... ].
-    If sender is not specified, signal is sent anonymously."""
-    senderkey = id(sender)
-    anykey = id(Any)
-    # Get receivers that receive *this* signal from *this* sender.
-    receivers = []
-    try:
-        receivers.extend(connections[senderkey][signal])
-    except KeyError:
-        pass
-    # Add receivers that receive *any* signal from *this* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[senderkey][Any]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Add receivers that receive *this* signal from *any* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[anykey][signal]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Add receivers that receive *any* signal from *any* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[anykey][Any]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Call each receiver with whatever arguments it can accept.
-    # Return a list of tuple pairs [(receiver, response), ... ].
-    responses = []
-    for receiver in receivers:
-        if type(receiver) is weakref.ReferenceType \
-        or isinstance(receiver, BoundMethodWeakref):
-            # Dereference the weak reference.
-            receiver = receiver()
-            if receiver is None:
-                # This receiver is dead, so skip it.
-                continue
-        response = _call(receiver, signal=signal, sender=sender, **kwds)
-        responses += [(receiver, response)]
-    return responses
-
-def _call(receiver, **kwds):
-    """Call receiver with only arguments it can accept."""
-##    if type(receiver) is types.InstanceType:
-    if hasattr(receiver, '__call__') and \
-       (hasattr(receiver.__call__, 'im_func') or hasattr(receiver.__call__, 'im_code')):
-        # receiver is a class instance; assume it is callable.
-        # Reassign receiver to the actual method that will be called.
-        receiver = receiver.__call__
-    if hasattr(receiver, 'im_func'):
-        # receiver is a method. Drop the first argument, usually 'self'.
-        fc = receiver.im_func.func_code
-        acceptable = fc.co_varnames[1:fc.co_argcount]
-    elif hasattr(receiver, 'func_code'):
-        # receiver is a function.
-        fc = receiver.func_code
-        acceptable = fc.co_varnames[0:fc.co_argcount]
-    else:
-        raise DispatcherError, 'Unknown receiver %s of type %s' % (receiver, type(receiver))
-    if not (fc.co_flags & 8):
-        # fc does not have a **kwds type parameter, therefore 
-        # remove unacceptable arguments.
-        for arg in kwds.keys():
-            if arg not in acceptable:
-                del kwds[arg]
-    return receiver(**kwds)
-
-
-def safeRef(object):
-    """Return a *safe* weak reference to a callable object."""
-    if hasattr(object, 'im_self'):
-        if object.im_self is not None:
-            # Turn a bound method into a BoundMethodWeakref instance.
-            # Keep track of these instances for lookup by disconnect().
-            selfkey = object.im_self
-            funckey = object.im_func
-            if not _boundMethods.has_key(selfkey):
-                _boundMethods[selfkey] = weakref.WeakKeyDictionary()
-            if not _boundMethods[selfkey].has_key(funckey):
-                _boundMethods[selfkey][funckey] = \
-                BoundMethodWeakref(boundMethod=object)
-            return _boundMethods[selfkey][funckey]
-    return weakref.ref(object, _removeReceiver)
-
-
-class BoundMethodWeakref:
-    """BoundMethodWeakref class."""
-
-    def __init__(self, boundMethod):
-        """Return a weak-reference-like instance for a bound method."""
-        self.isDead = 0
-        def remove(object, self=self):
-            """Set self.isDead to true when method or instance is destroyed."""
-            self.isDead = 1
-            _removeReceiver(receiver=self)
-        self.weakSelf = weakref.ref(boundMethod.im_self, remove)
-        self.weakFunc = weakref.ref(boundMethod.im_func, remove)
-
-    def __repr__(self):
-        """Return the closest representation."""
-        return '<bound method weakref for %s.%s>' % (self.weakSelf, self.weakFunc)
-
-    def __call__(self):
-        """Return a strong reference to the bound method."""
-        if self.isDead:
-            return None
-        else:
-            object = self.weakSelf()
-            method = self.weakFunc().__name__
-            try:  # wxPython hack to handle wxDead objects.
-                return getattr(object, method)
-            except AttributeError:
-##                 _removeReceiver(receiver=self)
-                return None
-
-
-def _removeReceiver(receiver):
-    """Remove receiver from connections."""
-    for senderkey in connections.keys():
-        for signal in connections[senderkey].keys():
-            receivers = connections[senderkey][signal]
-            try:
-                receivers.remove(receiver)
-            except:
-                pass
-            _cleanupConnections(senderkey, signal)
-            
-def _cleanupConnections(senderkey, signal):
-    """Delete any empty signals for senderkey. Delete senderkey if empty."""
-    receivers = connections[senderkey][signal]
-    if not receivers:
-        # No more connected receivers. Therefore, remove the signal.
-        signals = connections[senderkey]
-        del signals[signal]
-        if not signals:
-            # No more signal connections. Therefore, remove the sender.
-            _removeSender(senderkey)
-            
-def _removeSender(senderkey):
-    """Remove senderkey from connections."""
-    del connections[senderkey]
-    # Senderkey will only be in senders dictionary if sender 
-    # could be weakly referenced.
-    try:
-        del senders[senderkey]
-    except:
-        pass

wxPython/wxPython/py/document.py

@@ -1,49 +0,0 @@
-"""Document class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Document:
-    """Document class."""
-
-    def __init__(self, filename=None):
-        """Create a Document instance."""
-        self.filename = filename
-        self.filepath = None
-        self.filedir = None
-        self.filebase = None
-        self.fileext = None
-        if self.filename:
-            self.filepath = os.path.realpath(self.filename)
-            self.filedir, self.filename = os.path.split(self.filepath)
-            self.filebase, self.fileext = os.path.splitext(self.filename)
-
-    def read(self):
-        """Return contents of file."""
-        if self.filepath and os.path.exists(self.filepath):
-            f = file(self.filepath, 'rb')
-            try:
-                return f.read()
-            finally:
-                f.close()
-        else:
-            return ''
-
-    def write(self, text):
-        """Write text to file."""
-        try:
-            f = file(self.filepath, 'wb')
-            f.write(text)
-        finally:
-            if f:
-                f.close()

wxPython/wxPython/py/editor.py

@@ -1,839 +0,0 @@
-"""PyAlaCarte and PyAlaMode editors."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-from buffer import Buffer
-import crust
-import dispatcher
-import editwindow
-import frame
-from shell import Shell
-import version
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class EditorFrame(frame.Frame):
-    """Frame containing one editor."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaCarte',
-                 pos=wx.wxDefaultPosition, size=(800, 600), 
-                 style=wx.wxDEFAULT_FRAME_STYLE, filename=None):
-        """Create EditorFrame instance."""
-        frame.Frame.__init__(self, parent, id, title, pos, size, style)
-        self.buffers = {}
-        self.buffer = None  # Current buffer.
-        self.editor = None
-        self._defaultText = title + ' - the tastiest Python editor.'
-        self._statusText = self._defaultText
-        self.SetStatusText(self._statusText)
-        wx.EVT_IDLE(self, self.OnIdle)
-        self._setup()
-        if filename:
-            self.bufferCreate(filename)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Useful for subclasses."""
-        pass
-
-    def setEditor(self, editor):
-        self.editor = editor
-        self.buffer = self.editor.buffer
-        self.buffers[self.buffer.id] = self.buffer
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaCarte'
-        text = 'Another fine, flaky program.'
-        dialog = wx.wxMessageDialog(self, text, title,
-                                    wx.wxOK | wx.wxICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        for buffer in self.buffers.values():
-            self.buffer = buffer
-            if buffer.hasChanged():
-                cancel = self.bufferSuggestSave()
-                if cancel and event.CanVeto():
-                    event.Veto()
-                    return
-        self.Destroy()
-
-    def OnIdle(self, event):
-        """Event handler for idle time."""
-        self._updateStatus()
-        if hasattr(self, 'notebook'):
-            self._updateTabText()
-        self._updateTitle()
-        event.Skip()
-
-    def _updateStatus(self):
-        """Show current status information."""
-        if self.editor and hasattr(self.editor, 'getStatus'):
-            status = self.editor.getStatus()
-            text = 'File: %s  |  Line: %d  |  Column: %d' % status
-        else:
-            text = self._defaultText
-        if text != self._statusText:
-            self.SetStatusText(text)
-            self._statusText = text
-
-    def _updateTabText(self):
-        """Show current buffer information on notebook tab."""
-##         suffix = ' **'
-##         notebook = self.notebook
-##         selection = notebook.GetSelection()
-##         if selection == -1:
-##             return
-##         text = notebook.GetPageText(selection)
-##         window = notebook.GetPage(selection)
-##         if window.editor and window.editor.buffer.hasChanged():
-##             if text.endswith(suffix):
-##                 pass
-##             else:
-##                 notebook.SetPageText(selection, text + suffix)
-##         else:
-##             if text.endswith(suffix):
-##                 notebook.SetPageText(selection, text[:len(suffix)])
-
-    def _updateTitle(self):
-        """Show current title information."""
-        title = self.GetTitle()
-        if self.bufferHasChanged():
-            if title.startswith('* '):
-                pass
-            else:
-                self.SetTitle('* ' + title)
-        else:
-            if title.startswith('* '):
-                self.SetTitle(title[2:])
-        
-    def hasBuffer(self):
-        """Return True if there is a current buffer."""
-        if self.buffer:
-            return True
-        else:
-            return False
-
-    def bufferClose(self):
-        """Close buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferDestroy()
-        cancel = False
-        return cancel
-
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        self.bufferDestroy()
-        buffer = Buffer()
-        self.panel = panel = wx.wxPanel(parent=self, id=-1)
-        editor = Editor(parent=panel)
-        panel.editor = editor
-        sizer = wx.wxBoxSizer(wx.wxVERTICAL)
-        sizer.Add(editor.window, 1, wx.wxEXPAND)
-        panel.SetSizer(sizer)
-        panel.SetAutoLayout(True)
-        sizer.Layout()
-        buffer.addEditor(editor)
-        buffer.open(filename)
-        self.setEditor(editor)
-        self.editor.setFocus()
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        if self.buffer:
-            for editor in self.buffer.editors.values():
-                editor.destroy()
-            self.editor = None
-            del self.buffers[self.buffer.id]
-            self.buffer = None
-            self.panel.Destroy()
-
-    def bufferHasChanged(self):
-        """Return True if buffer has changed since last save."""
-        if self.buffer:
-            return self.buffer.hasChanged()
-        else:
-            return False
-
-    def bufferNew(self):
-        """Create new buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = openSingle(directory=filedir)
-        if result.path:
-            self.bufferCreate(result.path)
-        cancel = False
-        return cancel
-
-##     def bufferPrint(self):
-##         """Print buffer."""
-##         pass
-
-##     def bufferRevert(self):
-##         """Revert buffer to version of file on disk."""
-##         pass
-
-    def bufferSave(self):
-        """Save buffer to its file."""
-        if self.buffer.doc.filepath:
-            self.buffer.save()
-            cancel = False
-        else:
-            cancel = self.bufferSaveAs()
-        return cancel
-
-    def bufferSaveAs(self):
-        """Save buffer to a new filename."""
-        if self.bufferHasChanged() and self.buffer.doc.filepath:
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = saveSingle(directory=filedir)
-        if result.path:
-            self.buffer.saveAs(result.path)
-            cancel = False
-        else:
-            cancel = True
-        return cancel
-
-    def bufferSuggestSave(self):
-        """Suggest saving changes.  Return True if user selected Cancel."""
-        result = messageDialog(parent=None,
-                               message='%s has changed.\n'
-                                       'Would you like to save it first'
-                                       '?' % self.buffer.name,
-                               title='Save current file?')
-        if result.positive:
-            cancel = self.bufferSave()
-        else:
-            cancel = result.text == 'Cancel'
-        return cancel
-
-    def updateNamespace(self):
-        """Update the buffer namespace for autocompletion and calltips."""
-        if self.buffer.updateNamespace():
-            self.SetStatusText('Namespace updated')
-        else:
-            self.SetStatusText('Error executing, unable to update namespace')
-
-
-class EditorNotebookFrame(EditorFrame):
-    """Frame containing one or more editors in a notebook."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaMode',
-                 pos=wx.wxDefaultPosition, size=(800, 600), 
-                 style=wx.wxDEFAULT_FRAME_STYLE, filename=None):
-        """Create EditorNotebookFrame instance."""
-        self.notebook = None
-        EditorFrame.__init__(self, parent, id, title, pos,
-                             size, style, filename)
-        if self.notebook:
-            dispatcher.connect(receiver=self._editorChange,
-                               signal='EditorChange', sender=self.notebook)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Called automatically by base class during init."""
-        self.notebook = EditorNotebook(parent=self)
-        intro = 'PyCrust %s' % version.VERSION
-        import imp
-        module = imp.new_module('__main__')
-        import __builtin__
-        module.__dict__['__builtins__'] = __builtin__
-        namespace = module.__dict__.copy()
-        self.crust = crust.Crust(parent=self.notebook, intro=intro, locals=namespace)
-        self.shell = self.crust.shell
-        # Override the filling so that status messages go to the status bar.
-        self.crust.filling.tree.setStatusText = self.SetStatusText
-        # Override the shell so that status messages go to the status bar.
-        self.shell.setStatusText = self.SetStatusText
-        # Fix a problem with the sash shrinking to nothing.
-        self.crust.filling.SetSashPosition(200)
-        self.notebook.AddPage(page=self.crust, text='PyCrust', select=True)
-        self.setEditor(self.crust.editor)
-        self.crust.editor.SetFocus()
-
-    def _editorChange(self, editor):
-        """Editor change signal receiver."""
-        self.setEditor(editor)
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaMode'
-        text = 'Another fine, flaky program.'
-        dialog = wx.wxMessageDialog(self, text, title,
-                                    wx.wxOK | wx.wxICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def _updateTitle(self):
-        """Show current title information."""
-        pass
-##         title = self.GetTitle()
-##         if self.bufferHasChanged():
-##             if title.startswith('* '):
-##                 pass
-##             else:
-##                 self.SetTitle('* ' + title)
-##         else:
-##             if title.startswith('* '):
-##                 self.SetTitle(title[2:])
-        
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        buffer = Buffer()
-        panel = wx.wxPanel(parent=self.notebook, id=-1)
-        editor = Editor(parent=panel)
-        panel.editor = editor
-        sizer = wx.wxBoxSizer(wx.wxVERTICAL)
-        sizer.Add(editor.window, 1, wx.wxEXPAND)
-        panel.SetSizer(sizer)
-        panel.SetAutoLayout(True)
-        sizer.Layout()
-        buffer.addEditor(editor)
-        buffer.open(filename)
-        self.setEditor(editor)
-        self.notebook.AddPage(page=panel, text=self.buffer.name, select=True)
-        self.editor.setFocus()
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        selection = self.notebook.GetSelection()
-##         print "Destroy Selection:", selection
-        if selection > 0:  # Don't destroy the PyCrust tab.
-            if self.buffer:
-                del self.buffers[self.buffer.id]
-                self.buffer = None  # Do this before DeletePage().
-            self.notebook.DeletePage(selection)
-
-    def bufferNew(self):
-        """Create new buffer."""
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = openMultiple(directory=filedir)
-        for path in result.paths:
-            self.bufferCreate(path)
-        cancel = False
-        return cancel
-
-
-class EditorNotebook(wx.wxNotebook):
-    """A notebook containing a page for each editor."""
-
-    def __init__(self, parent):
-        """Create EditorNotebook instance."""
-        wx.wxNotebook.__init__(self, parent, id=-1)
-        wx.EVT_NOTEBOOK_PAGE_CHANGING(self, self.GetId(),
-                                      self.OnPageChanging)
-        wx.EVT_NOTEBOOK_PAGE_CHANGED(self, self.GetId(),
-                                     self.OnPageChanged)
-        wx.EVT_IDLE(self, self.OnIdle)
-
-    def OnIdle(self, event):
-        """Event handler for idle time."""
-        self._updateTabText()
-        event.Skip()
-
-    def _updateTabText(self):
-        """Show current buffer display name on all but first tab."""
-        size = 3
-        changed = ' **'
-        unchanged = ' --'
-        selection = self.GetSelection()
-        if selection < 1:
-            return
-        text = self.GetPageText(selection)
-        window = self.GetPage(selection)
-        if not window.editor:
-            return
-        if text.endswith(changed) or text.endswith(unchanged):
-            name = text[:-size]
-        else:
-            name = text
-        if name != window.editor.buffer.name:
-            text = window.editor.buffer.name
-        if window.editor.buffer.hasChanged():
-            if text.endswith(changed):
-                text = None
-            elif text.endswith(unchanged):
-                text = text[:-size] + changed
-            else:
-                text += changed
-        else:
-            if text.endswith(changed):
-                text = text[:-size] + unchanged
-            elif text.endswith(unchanged):
-                text = None
-            else:
-                text += unchanged
-        if text is not None:
-            self.SetPageText(selection, text)
-            self.Refresh()  # Needed on Win98.
-
-    def OnPageChanging(self, event):
-        """Page changing event handler."""
-        event.Skip()
-
-    def OnPageChanged(self, event):
-        """Page changed event handler."""
-        new = event.GetSelection()
-        window = self.GetPage(new)
-        dispatcher.send(signal='EditorChange', sender=self,
-                        editor=window.editor)
-        window.SetFocus()
-        event.Skip()
-
-
-class EditorShellNotebookFrame(EditorNotebookFrame):
-    """Frame containing a notebook containing EditorShellNotebooks."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaModeTest',
-                 pos=wx.wxDefaultPosition, size=(600, 400), 
-                 style=wx.wxDEFAULT_FRAME_STYLE,
-                 filename=None, singlefile=False):
-        """Create EditorShellNotebookFrame instance."""
-        self._singlefile = singlefile
-        EditorNotebookFrame.__init__(self, parent, id, title, pos,
-                                     size, style, filename)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Called automatically by base class during init."""
-        if not self._singlefile:
-            self.notebook = EditorNotebook(parent=self)
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaModePlus'
-        text = 'Another fine, flaky program.'
-        dialog = wx.wxMessageDialog(self, text, title,
-                                    wx.wxOK | wx.wxICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        if self._singlefile:
-            self.bufferDestroy()
-            notebook = EditorShellNotebook(parent=self,
-                                           filename=filename)
-            self.notebook = notebook
-        else:
-            notebook = EditorShellNotebook(parent=self.notebook,
-                                           filename=filename)
-        self.setEditor(notebook.editor)
-        if not self._singlefile:
-            self.notebook.AddPage(page=notebook, text=self.buffer.name,
-                                  select=True)
-        self.editor.setFocus()
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        if self.buffer:
-            self.editor = None
-            del self.buffers[self.buffer.id]
-            self.buffer = None  # Do this before DeletePage().
-        if self._singlefile:
-            self.notebook.Destroy()
-            self.notebook = None
-        else:
-            selection = self.notebook.GetSelection()
-##             print "Destroy Selection:", selection
-            self.notebook.DeletePage(selection)
-
-    def bufferNew(self):
-        """Create new buffer."""
-        if self._singlefile and self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        if self._singlefile and self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        if self._singlefile:
-            result = openSingle(directory=filedir)
-            if result.path:
-                self.bufferCreate(result.path)
-        else:
-            result = openMultiple(directory=filedir)
-            for path in result.paths:
-                self.bufferCreate(path)
-        cancel = False
-        return cancel
-
-
-class EditorShellNotebook(wx.wxNotebook):
-    """A notebook containing an editor page and a shell page."""
-
-    def __init__(self, parent, filename=None):
-        """Create EditorShellNotebook instance."""
-        wx.wxNotebook.__init__(self, parent, id=-1)
-        usePanels = True
-        if usePanels:
-            editorparent = editorpanel = wx.wxPanel(self, -1)
-            shellparent = shellpanel = wx.wxPanel(self, -1)
-        else:
-            editorparent = self
-            shellparent = self
-        self.buffer = Buffer()
-        self.editor = Editor(parent=editorparent)
-        self.buffer.addEditor(self.editor)
-        self.buffer.open(filename)
-        self.shell = Shell(parent=shellparent, locals=self.buffer.interp.locals,
-                           style=wx.wxCLIP_CHILDREN | wx.wxSUNKEN_BORDER)
-        self.buffer.interp.locals.clear()
-        if usePanels:
-            self.AddPage(page=editorpanel, text='Editor', select=True)
-            self.AddPage(page=shellpanel, text='Shell')
-            # Setup sizers
-            editorsizer = wx.wxBoxSizer(wx.wxVERTICAL)
-            editorsizer.Add(self.editor.window, 1, wx.wxEXPAND)
-            editorpanel.SetSizer(editorsizer)
-            editorpanel.SetAutoLayout(True)
-            shellsizer = wx.wxBoxSizer(wx.wxVERTICAL)
-            shellsizer.Add(self.shell, 1, wx.wxEXPAND)
-            shellpanel.SetSizer(shellsizer)
-            shellpanel.SetAutoLayout(True)
-        else:
-            self.AddPage(page=self.editor.window, text='Editor', select=True)
-            self.AddPage(page=self.shell, text='Shell')
-        self.editor.setFocus()
-        wx.EVT_NOTEBOOK_PAGE_CHANGED(self, self.GetId(), self.OnPageChanged)
-
-    def OnPageChanged(self, event):
-        """Page changed event handler."""
-        selection = event.GetSelection()
-        if selection == 0:
-            self.editor.setFocus()
-        else:
-            self.shell.SetFocus()
-        event.Skip()
-
-    def SetFocus(self):
-        wx.wxNotebook.SetFocus(self)
-        selection = self.GetSelection()
-        if selection == 0:
-            self.editor.setFocus()
-        else:
-            self.shell.SetFocus()
-
-
-class Editor:
-    """Editor having an EditWindow."""
-
-    def __init__(self, parent, id=-1, pos=wx.wxDefaultPosition,
-                 size=wx.wxDefaultSize,
-                 style=wx.wxCLIP_CHILDREN | wx.wxSUNKEN_BORDER):
-        """Create Editor instance."""
-        self.window = EditWindow(self, parent, id, pos, size, style)
-        self.id = self.window.GetId()
-        self.buffer = None
-        # Assign handlers for keyboard events.
-        wx.EVT_CHAR(self.window, self.OnChar)
-        wx.EVT_KEY_DOWN(self.window, self.OnKeyDown)
-
-    def _setBuffer(self, buffer, text):
-        """Set the editor to a buffer.  Private callback called by buffer."""
-        self.buffer = buffer
-        self.autoCompleteKeys = buffer.interp.getAutoCompleteKeys()
-        self.clearAll()
-        self.setText(text)
-        self.emptyUndoBuffer()
-        self.setSavePoint()
-
-    def destroy(self):
-        """Destroy all editor objects."""
-        self.window.Destroy()
-
-    def clearAll(self):
-        self.window.ClearAll()
-
-    def emptyUndoBuffer(self):
-        self.window.EmptyUndoBuffer()
-
-    def getStatus(self):
-        """Return (filepath, line, column) status tuple."""
-        pos = self.window.GetCurrentPos()
-        line = self.window.LineFromPosition(pos) + 1
-        col = self.window.GetColumn(pos)
-        if self.buffer:
-            name = self.buffer.doc.filepath or self.buffer.name
-        else:
-            name = ''
-        status = (name, line, col)
-        return status
-
-    def getText(self):
-        """Return contents of editor."""
-        return self.window.GetText()
-
-    def hasChanged(self):
-        """Return True if contents have changed."""
-        return self.window.GetModify()
-
-    def setFocus(self):
-        """Set the input focus to the editor window."""
-        self.window.SetFocus()
-
-    def setSavePoint(self):
-        self.window.SetSavePoint()
-
-    def setText(self, text):
-        """Set contents of editor."""
-        self.window.SetText(text)
-
-    def OnChar(self, event):
-        """Keypress event handler.
-        
-        Only receives an event if OnKeyDown calls event.Skip() for the
-        corresponding event."""
-
-        key = event.KeyCode()
-        if key in self.autoCompleteKeys:
-            # Usually the dot (period) key activates auto completion.
-            if self.window.AutoCompActive(): 
-                self.window.AutoCompCancel()
-            self.window.ReplaceSelection('')
-            self.window.AddText(chr(key))
-            text, pos = self.window.GetCurLine()
-            text = text[:pos]
-            if self.window.autoComplete: 
-                self.autoCompleteShow(text)
-        elif key == ord('('):
-            # The left paren activates a call tip and cancels an
-            # active auto completion.
-            if self.window.AutoCompActive(): 
-                self.window.AutoCompCancel()
-            self.window.ReplaceSelection('')
-            self.window.AddText('(')
-            text, pos = self.window.GetCurLine()
-            text = text[:pos]
-            self.autoCallTipShow(text)
-        else:
-            # Allow the normal event handling to take place.
-            event.Skip()
-
-    def OnKeyDown(self, event):
-        """Key down event handler."""
-
-        key = event.KeyCode()
-        # If the auto-complete window is up let it do its thing.
-        if self.window.AutoCompActive():
-            event.Skip()
-            return
-        controlDown = event.ControlDown()
-        altDown = event.AltDown()
-        shiftDown = event.ShiftDown()
-        # Let Ctrl-Alt-* get handled normally.
-        if controlDown and altDown:
-            event.Skip()
-        # Increase font size.
-        elif controlDown and key in (ord(']'),):
-            dispatcher.send(signal='FontIncrease')
-        # Decrease font size.
-        elif controlDown and key in (ord('['),):
-            dispatcher.send(signal='FontDecrease')
-        # Default font size.
-        elif controlDown and key in (ord('='),):
-            dispatcher.send(signal='FontDefault')
-        else:
-            event.Skip()
-
-    def autoCompleteShow(self, command):
-        """Display auto-completion popup list."""
-        list = self.buffer.interp.getAutoCompleteList(command, 
-                    includeMagic=self.window.autoCompleteIncludeMagic, 
-                    includeSingle=self.window.autoCompleteIncludeSingle, 
-                    includeDouble=self.window.autoCompleteIncludeDouble)
-        if list:
-            options = ' '.join(list)
-            offset = 0
-            self.window.AutoCompShow(offset, options)
-
-    def autoCallTipShow(self, command):
-        """Display argument spec and docstring in a popup window."""
-        if self.window.CallTipActive():
-            self.window.CallTipCancel()
-        (name, argspec, tip) = self.buffer.interp.getCallTip(command)
-        if tip:
-            dispatcher.send(signal='Shell.calltip', sender=self, calltip=tip)
-        if not self.window.autoCallTip:
-            return
-        if argspec:
-            startpos = self.window.GetCurrentPos()
-            self.window.AddText(argspec + ')')
-            endpos = self.window.GetCurrentPos()
-            self.window.SetSelection(endpos, startpos)
-        if tip:
-            curpos = self.window.GetCurrentPos()
-            size = len(name)
-            tippos = curpos - (size + 1)
-            fallback = curpos - self.window.GetColumn(curpos)
-            # In case there isn't enough room, only go back to the
-            # fallback.
-            tippos = max(tippos, fallback)
-            self.window.CallTipShow(tippos, tip)
-            self.window.CallTipSetHighlight(0, size)
-
-
-class EditWindow(editwindow.EditWindow):
-    """EditWindow based on StyledTextCtrl."""
-
-    def __init__(self, editor, parent, id=-1, pos=wx.wxDefaultPosition,
-                 size=wx.wxDefaultSize,
-                 style=wx.wxCLIP_CHILDREN | wx.wxSUNKEN_BORDER):
-        """Create EditWindow instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        self.editor = editor
-
-
-class DialogResults:
-    """DialogResults class."""
-
-    def __init__(self, returned):
-        """Create wrapper for results returned by dialog."""
-        self.returned = returned
-        self.positive = returned in (wx.wxID_OK, wx.wxID_YES)
-        self.text = self._asString()
-        
-
-    def __repr__(self):
-        return str(self.__dict__)
-
-    def _asString(self):
-        returned = self.returned
-        if returned == wx.wxID_OK:
-            return "Ok"
-        elif returned == wx.wxID_CANCEL:
-            return "Cancel"
-        elif returned == wx.wxID_YES:
-            return "Yes"
-        elif returned == wx.wxID_NO:
-            return "No"
-
-
-def fileDialog(parent=None, title='Open', directory='', filename='',
-               wildcard='All Files (*.*)|*.*',
-               style=wx.wxOPEN | wx.wxMULTIPLE):
-    """File dialog wrapper function."""
-    dialog = wx.wxFileDialog(parent, title, directory, filename,
-                             wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.paths = dialog.GetPaths()
-    else:
-        result.paths = []
-    dialog.Destroy()
-    return result
-
-
-def openSingle(parent=None, title='Open', directory='', filename='',
-               wildcard='All Files (*.*)|*.*', style=wx.wxOPEN):
-    """File dialog wrapper function."""
-    dialog = wx.wxFileDialog(parent, title, directory, filename,
-                             wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def openMultiple(parent=None, title='Open', directory='', filename='',
-                 wildcard='All Files (*.*)|*.*',
-                 style=wx.wxOPEN | wx.wxMULTIPLE):
-    """File dialog wrapper function."""
-    return fileDialog(parent, title, directory, filename, wildcard, style)
-
-
-def saveSingle(parent=None, title='Save', directory='', filename='',
-               wildcard='All Files (*.*)|*.*',
-               style=wx.wxSAVE | wx.wxHIDE_READONLY | wx.wxOVERWRITE_PROMPT):
-    """File dialog wrapper function."""
-    dialog = wx.wxFileDialog(parent, title, directory, filename,
-                             wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def directory(parent=None, message='Choose a directory', path='', style=0,
-              pos=wx.wxDefaultPosition, size=wx.wxDefaultSize):
-    """Dir dialog wrapper function."""
-    dialog = wx.wxDirDialog(parent, message, path, style, pos, size)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def messageDialog(parent=None, message='', title='Message box',
-                  style=wx.wxYES_NO | wx.wxCANCEL | wx.wxCENTRE | wx.wxICON_QUESTION,
-                  pos=wx.wxDefaultPosition):
-    """Message dialog wrapper function."""
-    dialog = wx.wxMessageDialog(parent, message, title, style, pos)
-    result = DialogResults(dialog.ShowModal())
-    dialog.Destroy()
-    return result

wxPython/wxPython/py/editwindow.py

@@ -1,195 +0,0 @@
-"""EditWindow class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-from wxPython import stc
-
-import keyword
-import os
-import sys
-import time
-
-import dispatcher
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-if wx.wxPlatform == '__WXMSW__':
-    FACES = { 'times'  : 'Times New Roman',
-              'mono'   : 'Courier New',
-              'helv'   : 'Lucida Console',
-              'lucida' : 'Lucida Console',
-              'other'  : 'Comic Sans MS',
-              'size'   : 10,
-              'lnsize' : 9,
-              'backcol': '#FFFFFF',
-            }
-else:  # GTK
-    FACES = { 'times'  : 'Times',
-              'mono'   : 'Courier',
-              'helv'   : 'Helvetica',
-              'other'  : 'new century schoolbook',
-              'size'   : 12,
-              'lnsize' : 10,
-              'backcol': '#FFFFFF',
-            }
-
-
-class EditWindow(stc.wxStyledTextCtrl):
-    """EditWindow based on StyledTextCtrl."""
-
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.wxDefaultPosition,
-                 size=wx.wxDefaultSize, style=wx.wxCLIP_CHILDREN | wx.wxSUNKEN_BORDER):
-        """Create EditWindow instance."""
-        stc.wxStyledTextCtrl.__init__(self, parent, id, pos, size, style)
-        self.__config()
-        stc.EVT_STC_UPDATEUI(self, id, self.OnUpdateUI)
-        dispatcher.connect(receiver=self._fontsizer, signal='FontIncrease')
-        dispatcher.connect(receiver=self._fontsizer, signal='FontDecrease')
-        dispatcher.connect(receiver=self._fontsizer, signal='FontDefault')
-
-    def _fontsizer(self, signal):
-        """Receiver for Font* signals."""
-        size = self.GetZoom()
-        if signal == 'FontIncrease':
-            size += 1
-        elif signal == 'FontDecrease':
-            size -= 1
-        elif signal == 'FontDefault':
-            size = 0
-        self.SetZoom(size)
-
-    def __config(self):
-        """Configure shell based on user preferences."""
-        self.SetMarginType(1, stc.wxSTC_MARGIN_NUMBER)
-        self.SetMarginWidth(1, 40)
-
-        self.SetLexer(stc.wxSTC_LEX_PYTHON)
-        self.SetKeyWords(0, ' '.join(keyword.kwlist))
-
-        self.setStyles(FACES)
-        self.SetViewWhiteSpace(False)
-        self.SetTabWidth(4)
-        self.SetUseTabs(False)
-        # Do we want to automatically pop up command completion options?
-        self.autoComplete = True
-        self.autoCompleteIncludeMagic = True
-        self.autoCompleteIncludeSingle = True
-        self.autoCompleteIncludeDouble = True
-        self.autoCompleteCaseInsensitive = True
-        self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive)
-        self.AutoCompSetAutoHide(False)
-        self.AutoCompStops(' .,;:([)]}\'"\\<>%^&+-=*/|`')
-        # Do we want to automatically pop up command argument help?
-        self.autoCallTip = True
-        self.CallTipSetBackground(wx.wxColour(255, 255, 232))
-        self.SetWrapMode(False)
-        try:
-            self.SetEndAtLastLine(False)
-        except AttributeError:
-            pass
-
-    def setStyles(self, faces):
-        """Configure font size, typeface and color for lexer."""
-
-        # Default style
-        self.StyleSetSpec(stc.wxSTC_STYLE_DEFAULT,
-                          "face:%(mono)s,size:%(size)d,back:%(backcol)s" % \
-                          faces)
-
-        self.StyleClearAll()
-
-        # Built in styles
-        self.StyleSetSpec(stc.wxSTC_STYLE_LINENUMBER,
-                          "back:#C0C0C0,face:%(mono)s,size:%(lnsize)d" % faces)
-        self.StyleSetSpec(stc.wxSTC_STYLE_CONTROLCHAR,
-                          "face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.wxSTC_STYLE_BRACELIGHT,
-                          "fore:#0000FF,back:#FFFF88")
-        self.StyleSetSpec(stc.wxSTC_STYLE_BRACEBAD,
-                          "fore:#FF0000,back:#FFFF88")
-
-        # Python styles
-        self.StyleSetSpec(stc.wxSTC_P_DEFAULT,
-                          "face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.wxSTC_P_COMMENTLINE,
-                          "fore:#007F00,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.wxSTC_P_NUMBER,
-                          "")
-        self.StyleSetSpec(stc.wxSTC_P_STRING,
-                          "fore:#7F007F,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.wxSTC_P_CHARACTER,
-                          "fore:#7F007F,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.wxSTC_P_WORD,
-                          "fore:#00007F,bold")
-        self.StyleSetSpec(stc.wxSTC_P_TRIPLE,
-                          "fore:#7F0000")
-        self.StyleSetSpec(stc.wxSTC_P_TRIPLEDOUBLE,
-                          "fore:#000033,back:#FFFFE8")
-        self.StyleSetSpec(stc.wxSTC_P_CLASSNAME,
-                          "fore:#0000FF,bold")
-        self.StyleSetSpec(stc.wxSTC_P_DEFNAME,
-                          "fore:#007F7F,bold")
-        self.StyleSetSpec(stc.wxSTC_P_OPERATOR,
-                          "")
-        self.StyleSetSpec(stc.wxSTC_P_IDENTIFIER,
-                          "")
-        self.StyleSetSpec(stc.wxSTC_P_COMMENTBLOCK,
-                          "fore:#7F7F7F")
-        self.StyleSetSpec(stc.wxSTC_P_STRINGEOL,
-                          "fore:#000000,face:%(mono)s,back:#E0C0E0,eolfilled" % faces)
-
-    def OnUpdateUI(self, event):
-        """Check for matching braces."""
-        # If the auto-complete window is up let it do its thing.
-        if self.AutoCompActive() or self.CallTipActive():
-            return
-        braceAtCaret = -1
-        braceOpposite = -1
-        charBefore = None
-        caretPos = self.GetCurrentPos()
-        if caretPos > 0:
-            charBefore = self.GetCharAt(caretPos - 1)
-            styleBefore = self.GetStyleAt(caretPos - 1)
-
-        # Check before.
-        if charBefore and chr(charBefore) in '[]{}()' \
-        and styleBefore == stc.wxSTC_P_OPERATOR:
-            braceAtCaret = caretPos - 1
-
-        # Check after.
-        if braceAtCaret < 0:
-            charAfter = self.GetCharAt(caretPos)
-            styleAfter = self.GetStyleAt(caretPos)
-            if charAfter and chr(charAfter) in '[]{}()' \
-            and styleAfter == stc.wxSTC_P_OPERATOR:
-                braceAtCaret = caretPos
-
-        if braceAtCaret >= 0:
-            braceOpposite = self.BraceMatch(braceAtCaret)
-
-        if braceAtCaret != -1  and braceOpposite == -1:
-            self.BraceBadLight(braceAtCaret)
-        else:
-            self.BraceHighlight(braceAtCaret, braceOpposite)
-
-    def CanCut(self):
-        """Return true if text is selected and can be cut."""
-        return self.CanCopy()
-
-    def CanCopy(self):
-        """Return true if text is selected and can be copied."""
-        return self.GetSelectionStart() != self.GetSelectionEnd()
-
-    def CanEdit(self):
-        """Return true if editing should succeed."""
-        return True

wxPython/wxPython/py/filling.py

@@ -1,335 +0,0 @@
-"""PyCrust Filling is the gui tree control through which a user can
-navigate the local namespace or any object."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-import dispatcher
-import editwindow
-import inspect
-import introspect
-import keyword
-import sys
-import types
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-COMMONTYPES = [getattr(types, t) for t in dir(types) \
-               if not t.startswith('_') \
-               and t not in ('ClassType', 'InstanceType', 'ModuleType')]
-
-DOCTYPES = ('BuiltinFunctionType', 'BuiltinMethodType', 'ClassType',
-            'FunctionType', 'GeneratorType', 'InstanceType',
-            'LambdaType', 'MethodType', 'ModuleType',
-            'UnboundMethodType', 'method-wrapper')
-
-SIMPLETYPES = [getattr(types, t) for t in dir(types) \
-               if not t.startswith('_') and t not in DOCTYPES]
-
-try:
-    COMMONTYPES.append(type(''.__repr__))  # Method-wrapper in version 2.2.x.
-except AttributeError:
-    pass
-
-
-class FillingTree(wx.wxTreeCtrl):
-    """PyCrust FillingTree based on wxTreeCtrl."""
-    
-    name = 'PyCrust Filling Tree'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.wxDefaultPosition,
-                 size=wx.wxDefaultSize, style=wx.wxTR_DEFAULT_STYLE,
-                 rootObject=None, rootLabel=None, rootIsNamespace=False,
-                 static=False):
-        """Create a PyCrust FillingTree instance."""
-        wx.wxTreeCtrl.__init__(self, parent, id, pos, size, style)
-        self.rootIsNamespace = rootIsNamespace
-        import __main__
-        if rootObject is None:
-            rootObject = __main__.__dict__
-            self.rootIsNamespace = True
-        if rootObject is __main__.__dict__ and rootLabel is None:
-            rootLabel = 'locals()'
-        if not rootLabel:
-            rootLabel = 'Ingredients'
-        rootData = wx.wxTreeItemData(rootObject)
-        self.item = self.root = self.AddRoot(rootLabel, -1, -1, rootData)
-        self.SetItemHasChildren(self.root, self.objHasChildren(rootObject))
-        wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding)
-        wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed)
-        wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
-        wx.EVT_TREE_ITEM_ACTIVATED(self, self.GetId(), self.OnItemActivated)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.display()
-
-    def OnItemExpanding(self, event):
-        """Add children to the item."""
-        busy = wx.wxBusyCursor()
-        item = event.GetItem()
-        if self.IsExpanded(item):
-            return
-        self.addChildren(item)
-#        self.SelectItem(item)
-
-    def OnItemCollapsed(self, event):
-        """Remove all children from the item."""
-        busy = wx.wxBusyCursor()
-        item = event.GetItem()
-#        self.CollapseAndReset(item)
-#        self.DeleteChildren(item)
-#        self.SelectItem(item)
-
-    def OnSelChanged(self, event):
-        """Display information about the item."""
-        busy = wx.wxBusyCursor()
-        self.item = event.GetItem()
-        self.display()
-
-    def OnItemActivated(self, event):
-        """Launch a DirFrame."""
-        item = event.GetItem()
-        text = self.getFullName(item)
-        obj = self.GetPyData(item)
-        frame = FillingFrame(parent=self, size=(600, 100), rootObject=obj,
-                             rootLabel=text, rootIsNamespace=False)
-        frame.Show()
-
-    def objHasChildren(self, obj):
-        """Return true if object has children."""
-        if self.objGetChildren(obj):
-            return True
-        else:
-            return False
-
-    def objGetChildren(self, obj):
-        """Return dictionary with attributes or contents of object."""
-        busy = wx.wxBusyCursor()
-        otype = type(obj)
-        if otype is types.DictType \
-        or str(otype)[17:23] == 'BTrees' and hasattr(obj, 'keys'):
-            return obj
-        d = {}
-        if otype is types.ListType or otype is types.TupleType:
-            for n in range(len(obj)):
-                key = '[' + str(n) + ']'
-                d[key] = obj[n]
-        if otype not in COMMONTYPES:
-            for key in introspect.getAttributeNames(obj):
-                # Believe it or not, some attributes can disappear,
-                # such as the exc_traceback attribute of the sys
-                # module. So this is nested in a try block.
-                try:
-                    d[key] = getattr(obj, key)
-                except:
-                    pass
-        return d
-
-    def addChildren(self, item):
-        self.DeleteChildren(item)
-        obj = self.GetPyData(item)
-        children = self.objGetChildren(obj)
-        if not children:
-            return
-        keys = children.keys()
-        keys.sort(lambda x, y: cmp(x.lower(), y.lower()))
-        for key in keys:
-            itemtext = str(key)
-            # Show string dictionary items with single quotes, except
-            # for the first level of items, if they represent a
-            # namespace.
-            if type(obj) is types.DictType \
-            and type(key) is types.StringType \
-            and (item != self.root \
-                 or (item == self.root and not self.rootIsNamespace)):
-                itemtext = repr(key)
-            child = children[key]
-            data = wx.wxTreeItemData(child)
-            branch = self.AppendItem(parent=item, text=itemtext, data=data)
-            self.SetItemHasChildren(branch, self.objHasChildren(child))
-
-    def display(self):
-        item = self.item
-        if self.IsExpanded(item):
-            self.addChildren(item)
-        self.setText('')
-        obj = self.GetPyData(item)
-        if wx.wxPlatform == '__WXMSW__':
-            if obj is None: # Windows bug fix.
-                return
-        self.SetItemHasChildren(item, self.objHasChildren(obj))
-        otype = type(obj)
-        text = ''
-        text += self.getFullName(item)
-        text += '\n\nType: ' + str(otype)
-        try:
-            value = str(obj)
-        except:
-            value = ''
-        if otype is types.StringType or otype is types.UnicodeType:
-            value = repr(obj)
-        text += '\n\nValue: ' + value
-        if otype not in SIMPLETYPES:
-            try:
-                text += '\n\nDocstring:\n\n"""' + \
-                        inspect.getdoc(obj).strip() + '"""'
-            except:
-                pass
-        if otype is types.InstanceType:
-            try:
-                text += '\n\nClass Definition:\n\n' + \
-                        inspect.getsource(obj.__class__)
-            except:
-                pass
-        else:
-            try:
-                text += '\n\nSource Code:\n\n' + \
-                        inspect.getsource(obj)
-            except:
-                pass
-        self.setText(text)
-
-    def getFullName(self, item, partial=''):
-        """Return a syntactically proper name for item."""
-        name = self.GetItemText(item)
-        parent = None
-        obj = None
-        if item != self.root:
-            parent = self.GetItemParent(item)
-            obj = self.GetPyData(parent)
-        # Apply dictionary syntax to dictionary items, except the root
-        # and first level children of a namepace.
-        if (type(obj) is types.DictType \
-            or str(type(obj))[17:23] == 'BTrees' \
-            and hasattr(obj, 'keys')) \
-        and ((item != self.root and parent != self.root) \
-            or (parent == self.root and not self.rootIsNamespace)):
-            name = '[' + name + ']'
-        # Apply dot syntax to multipart names.
-        if partial:
-            if partial[0] == '[':
-                name += partial
-            else:
-                name += '.' + partial
-        # Repeat for everything but the root item
-        # and first level children of a namespace.
-        if (item != self.root and parent != self.root) \
-        or (parent == self.root and not self.rootIsNamespace):
-            name = self.getFullName(parent, partial=name)
-        return name
-
-    def setText(self, text):
-        """Display information about the current selection."""
-
-        # This method will likely be replaced by the enclosing app to
-        # do something more interesting, like write to a text control.
-        print text
-
-    def setStatusText(self, text):
-        """Display status information."""
-
-        # This method will likely be replaced by the enclosing app to
-        # do something more interesting, like write to a status bar.
-        print text
-
-
-class FillingText(editwindow.EditWindow):
-    """FillingText based on StyledTextCtrl."""
-
-    name = 'PyFilling Text'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.wxDefaultPosition,
-                 size=wx.wxDefaultSize, style=wx.wxCLIP_CHILDREN,
-                 static=False):
-        """Create a FillingText instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        # Configure various defaults and user preferences.
-        self.SetReadOnly(True)
-        self.SetWrapMode(True)
-        self.SetMarginWidth(1, 0)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.Refresh()
-
-    def SetText(self, *args, **kwds):
-        self.SetReadOnly(False)
-        editwindow.EditWindow.SetText(self, *args, **kwds)
-        self.SetReadOnly(True)
-
-
-class Filling(wx.wxSplitterWindow):
-    """Filling based on wxSplitterWindow."""
-
-    name = 'PyFilling'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.wxDefaultPosition,
-                 size=wx.wxDefaultSize, style=wx.wxSP_3D,
-                 name='Filling Window', rootObject=None,
-                 rootLabel=None, rootIsNamespace=False, static=False):
-        """Create a Filling instance."""
-        wx.wxSplitterWindow.__init__(self, parent, id, pos, size, style, name)
-        self.tree = FillingTree(parent=self, rootObject=rootObject,
-                                rootLabel=rootLabel,
-                                rootIsNamespace=rootIsNamespace,
-                                static=static)
-        self.text = FillingText(parent=self, static=static)
-        self.SplitVertically(self.tree, self.text, 130)
-        self.SetMinimumPaneSize(1)
-        # Override the filling so that descriptions go to FillingText.
-        self.tree.setText = self.text.SetText
-        # Display the root item.
-##        self.tree.SelectItem(self.tree.root)
-        self.tree.display()
-
-
-class FillingFrame(wx.wxFrame):
-    """Frame containing the namespace tree component."""
-
-    name = 'PyFilling Frame'
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='PyFilling',
-                 pos=wx.wxDefaultPosition, size=(600, 400),
-                 style=wx.wxDEFAULT_FRAME_STYLE, rootObject=None,
-                 rootLabel=None, rootIsNamespace=False, static=False):
-        """Create a FillingFrame instance."""
-        wx.wxFrame.__init__(self, parent, id, title, pos, size, style)
-        intro = 'PyFilling - The Tastiest Namespace Inspector'
-        self.CreateStatusBar()
-        self.SetStatusText(intro)
-        import images
-        self.SetIcon(images.getPyCrustIcon())
-        self.filling = Filling(parent=self, rootObject=rootObject,
-                               rootLabel=rootLabel,
-                               rootIsNamespace=rootIsNamespace,
-                               static=static)
-        # Override so that status messages go to the status bar.
-        self.filling.tree.setStatusText = self.SetStatusText
-
-
-class App(wx.wxApp):
-    """PyFilling standalone application."""
-
-    def OnInit(self):
-        wx.wxInitAllImageHandlers()
-        self.fillingFrame = FillingFrame()
-        self.fillingFrame.Show(True)
-        self.SetTopWindow(self.fillingFrame)
-        return True

wxPython/wxPython/py/frame.py

@@ -1,348 +0,0 @@
-"""Base frame with menu."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-ID_NEW = wx.wxID_NEW
-ID_OPEN = wx.wxID_OPEN
-ID_REVERT = wx.wxID_REVERT
-ID_CLOSE = wx.wxID_CLOSE
-ID_SAVE = wx.wxID_SAVE
-ID_SAVEAS = wx.wxID_SAVEAS
-ID_PRINT = wx.wxID_PRINT
-ID_EXIT = wx.wxID_EXIT
-ID_UNDO = wx.wxID_UNDO
-ID_REDO = wx.wxID_REDO
-ID_CUT = wx.wxID_CUT
-ID_COPY = wx.wxID_COPY
-ID_PASTE = wx.wxID_PASTE
-ID_CLEAR = wx.wxID_CLEAR
-ID_SELECTALL = wx.wxID_SELECTALL
-ID_ABOUT = wx.wxID_ABOUT
-ID_AUTOCOMP = wx.wxNewId()
-ID_AUTOCOMP_SHOW = wx.wxNewId()
-ID_AUTOCOMP_MAGIC = wx.wxNewId()
-ID_AUTOCOMP_SINGLE = wx.wxNewId()
-ID_AUTOCOMP_DOUBLE = wx.wxNewId()
-ID_CALLTIPS = wx.wxNewId()
-ID_CALLTIPS_SHOW = wx.wxNewId()
-ID_COPY_PLUS = wx.wxNewId()
-ID_NAMESPACE = wx.wxNewId()
-ID_PASTE_PLUS = wx.wxNewId()
-ID_WRAP = wx.wxNewId()
-
-
-class Frame(wx.wxFrame):
-    """Frame with standard menu items."""
-
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='Editor',
-                 pos=wx.wxDefaultPosition, size=wx.wxDefaultSize, 
-                 style=wx.wxDEFAULT_FRAME_STYLE):
-        """Create a Frame instance."""
-        wx.wxFrame.__init__(self, parent, id, title, pos, size, style)
-        self.CreateStatusBar()
-        self.SetStatusText('Frame')
-        import images
-        self.SetIcon(images.getPyCrustIcon())
-        self.__createMenus()
-        wx.EVT_CLOSE(self, self.OnClose)
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        self.Destroy()
-
-    def __createMenus(self):
-        m = self.fileMenu = wx.wxMenu()
-        m.Append(ID_NEW, '&New \tCtrl+N',
-                 'New file')
-        m.Append(ID_OPEN, '&Open... \tCtrl+O',
-                 'Open file')
-        m.AppendSeparator()
-        m.Append(ID_REVERT, '&Revert \tCtrl+R',
-                 'Revert to last saved version')
-        m.Append(ID_CLOSE, '&Close \tCtrl+W',
-                 'Close file')
-        m.AppendSeparator()
-        m.Append(ID_SAVE, '&Save... \tCtrl+S',
-                 'Save file')
-        m.Append(ID_SAVEAS, 'Save &As \tShift+Ctrl+S',
-                 'Save file with new name')
-        m.AppendSeparator()
-        m.Append(ID_PRINT, '&Print... \tCtrl+P',
-                 'Print file')
-        m.AppendSeparator()
-        m.Append(ID_NAMESPACE, '&Update Namespace \tShift+Ctrl+N',
-                 'Update namespace for autocompletion and calltips')
-        m.AppendSeparator()
-        m.Append(ID_EXIT, 'E&xit', 'Exit Program')
-
-        m = self.editMenu = wx.wxMenu()
-        m.Append(ID_UNDO, '&Undo \tCtrl+Z',
-                 'Undo the last action')
-        m.Append(ID_REDO, '&Redo \tCtrl+Y',
-                 'Redo the last undone action')
-        m.AppendSeparator()
-        m.Append(ID_CUT, 'Cu&t \tCtrl+X',
-                 'Cut the selection')
-        m.Append(ID_COPY, '&Copy \tCtrl+C',
-                 'Copy the selection')
-        m.Append(ID_COPY_PLUS, 'Cop&y Plus \tShift+Ctrl+C',
-                 'Copy the selection - retaining prompts')
-        m.Append(ID_PASTE, '&Paste \tCtrl+V', 'Paste from clipboard')
-        m.Append(ID_PASTE_PLUS, 'Past&e Plus \tShift+Ctrl+V',
-                 'Paste and run commands')
-        m.AppendSeparator()
-        m.Append(ID_CLEAR, 'Cle&ar',
-                 'Delete the selection')
-        m.Append(ID_SELECTALL, 'Select A&ll \tCtrl+A',
-                 'Select all text')
-
-        m = self.autocompMenu = wx.wxMenu()
-        m.Append(ID_AUTOCOMP_SHOW, 'Show Auto Completion',
-                 'Show auto completion list', 1)
-        m.Append(ID_AUTOCOMP_MAGIC, 'Include Magic Attributes',
-                 'Include attributes visible to __getattr__ and __setattr__',
-                 1)
-        m.Append(ID_AUTOCOMP_SINGLE, 'Include Single Underscores',
-                 'Include attibutes prefixed by a single underscore', 1)
-        m.Append(ID_AUTOCOMP_DOUBLE, 'Include Double Underscores',
-                 'Include attibutes prefixed by a double underscore', 1)
-
-        m = self.calltipsMenu = wx.wxMenu()
-        m.Append(ID_CALLTIPS_SHOW, 'Show Call Tips',
-                 'Show call tips with argument signature and docstring', 1)
-
-        m = self.optionsMenu = wx.wxMenu()
-        m.AppendMenu(ID_AUTOCOMP, '&Auto Completion', self.autocompMenu,
-                     'Auto Completion Options')
-        m.AppendMenu(ID_CALLTIPS, '&Call Tips', self.calltipsMenu,
-                     'Call Tip Options')
-        m.Append(ID_WRAP, '&Wrap Lines',
-                 'Wrap lines at right edge', 1)
-
-        m = self.helpMenu = wx.wxMenu()
-        m.AppendSeparator()
-        m.Append(ID_ABOUT, '&About...', 'About this program')
-
-        b = self.menuBar = wx.wxMenuBar()
-        b.Append(self.fileMenu, '&File')
-        b.Append(self.editMenu, '&Edit')
-        b.Append(self.optionsMenu, '&Options')
-        b.Append(self.helpMenu, '&Help')
-        self.SetMenuBar(b)
-
-        wx.EVT_MENU(self, ID_NEW, self.OnFileNew)
-        wx.EVT_MENU(self, ID_OPEN, self.OnFileOpen)
-        wx.EVT_MENU(self, ID_REVERT, self.OnFileRevert)
-        wx.EVT_MENU(self, ID_CLOSE, self.OnFileClose)
-        wx.EVT_MENU(self, ID_SAVE, self.OnFileSave)
-        wx.EVT_MENU(self, ID_SAVEAS, self.OnFileSaveAs)
-        wx.EVT_MENU(self, ID_NAMESPACE, self.OnFileUpdateNamespace)
-        wx.EVT_MENU(self, ID_PRINT, self.OnFilePrint)
-        wx.EVT_MENU(self, ID_EXIT, self.OnExit)
-        wx.EVT_MENU(self, ID_UNDO, self.OnUndo)
-        wx.EVT_MENU(self, ID_REDO, self.OnRedo)
-        wx.EVT_MENU(self, ID_CUT, self.OnCut)
-        wx.EVT_MENU(self, ID_COPY, self.OnCopy)
-        wx.EVT_MENU(self, ID_COPY_PLUS, self.OnCopyPlus)
-        wx.EVT_MENU(self, ID_PASTE, self.OnPaste)
-        wx.EVT_MENU(self, ID_PASTE_PLUS, self.OnPastePlus)
-        wx.EVT_MENU(self, ID_CLEAR, self.OnClear)
-        wx.EVT_MENU(self, ID_SELECTALL, self.OnSelectAll)
-        wx.EVT_MENU(self, ID_ABOUT, self.OnAbout)
-        wx.EVT_MENU(self, ID_AUTOCOMP_SHOW, self.OnAutoCompleteShow)
-        wx.EVT_MENU(self, ID_AUTOCOMP_MAGIC, self.OnAutoCompleteMagic)
-        wx.EVT_MENU(self, ID_AUTOCOMP_SINGLE, self.OnAutoCompleteSingle)
-        wx.EVT_MENU(self, ID_AUTOCOMP_DOUBLE, self.OnAutoCompleteDouble)
-        wx.EVT_MENU(self, ID_CALLTIPS_SHOW, self.OnCallTipsShow)
-        wx.EVT_MENU(self, ID_WRAP, self.OnWrap)
-
-        wx.EVT_UPDATE_UI(self, ID_NEW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_OPEN, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_REVERT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CLOSE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SAVE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SAVEAS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_NAMESPACE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PRINT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_UNDO, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_REDO, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CUT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_COPY, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_COPY_PLUS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PASTE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PASTE_PLUS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CLEAR, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SELECTALL, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_SHOW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_MAGIC, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_SINGLE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_DOUBLE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CALLTIPS_SHOW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_WRAP, self.OnUpdateMenu)
-
-    def OnFileNew(self, event):
-        self.bufferNew()
-
-    def OnFileOpen(self, event):
-        self.bufferOpen()
-
-    def OnFileRevert(self, event):
-        self.bufferRevert()
-
-    def OnFileClose(self, event):
-        self.bufferClose()
-
-    def OnFileSave(self, event):
-        self.bufferSave()
-
-    def OnFileSaveAs(self, event):
-        self.bufferSaveAs()
-
-    def OnFileUpdateNamespace(self, event):
-        self.updateNamespace()
-
-    def OnFilePrint(self, event):
-        self.bufferPrint()
-
-    def OnExit(self, event):
-        self.Close(False)
-
-    def OnUndo(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.Undo()
-
-    def OnRedo(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.Redo()
-
-    def OnCut(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.Cut()
-
-    def OnCopy(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.Copy()
-
-    def OnCopyPlus(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.CopyWithPrompts()
-
-    def OnPaste(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.Paste()
-
-    def OnPastePlus(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.PasteAndRun()
-
-    def OnClear(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.Clear()
-
-    def OnSelectAll(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.SelectAll()
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About'
-        text = 'Your message here.'
-        dialog = wx.wxMessageDialog(self, text, title,
-                                    wx.wxOK | wx.wxICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def OnAutoCompleteShow(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.autoComplete = event.IsChecked()
-
-    def OnAutoCompleteMagic(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.autoCompleteIncludeMagic = event.IsChecked()
-
-    def OnAutoCompleteSingle(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.autoCompleteIncludeSingle = event.IsChecked()
-
-    def OnAutoCompleteDouble(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.autoCompleteIncludeDouble = event.IsChecked()
-
-    def OnCallTipsShow(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.autoCallTip = event.IsChecked()
-
-    def OnWrap(self, event):
-        win = wx.wxWindow_FindFocus()
-        win.SetWrapMode(event.IsChecked())
-
-    def OnUpdateMenu(self, event):
-        """Update menu items based on current status and context."""
-        win = wx.wxWindow_FindFocus()
-        id = event.GetId()
-        event.Enable(True)
-        try:
-            if id == ID_NEW:
-                event.Enable(hasattr(self, 'bufferNew'))
-            elif id == ID_OPEN:
-                event.Enable(hasattr(self, 'bufferOpen'))
-            elif id == ID_REVERT:
-                event.Enable(hasattr(self, 'bufferRevert') and self.hasBuffer())
-            elif id == ID_CLOSE:
-                event.Enable(hasattr(self, 'bufferClose') and self.hasBuffer())
-            elif id == ID_SAVE:
-                event.Enable(hasattr(self, 'bufferSave') and self.bufferHasChanged())
-            elif id == ID_SAVEAS:
-                event.Enable(hasattr(self, 'bufferSaveAs') and self.hasBuffer())
-            elif id == ID_NAMESPACE:
-                event.Enable(hasattr(self, 'updateNamespace') and self.hasBuffer())
-            elif id == ID_PRINT:
-                event.Enable(hasattr(self, 'bufferPrint') and self.hasBuffer())
-            elif id == ID_UNDO:
-                event.Enable(win.CanUndo())
-            elif id == ID_REDO:
-                event.Enable(win.CanRedo())
-            elif id == ID_CUT:
-                event.Enable(win.CanCut())
-            elif id == ID_COPY:
-                event.Enable(win.CanCopy())
-            elif id == ID_COPY_PLUS:
-                event.Enable(win.CanCopy() and hasattr(win, 'CopyWithPrompts'))
-            elif id == ID_PASTE:
-                event.Enable(win.CanPaste())
-            elif id == ID_PASTE_PLUS:
-                event.Enable(win.CanPaste() and hasattr(win, 'PasteAndRun'))
-            elif id == ID_CLEAR:
-                event.Enable(win.CanCut())
-            elif id == ID_SELECTALL:
-                event.Enable(hasattr(win, 'SelectAll'))
-            elif id == ID_AUTOCOMP_SHOW:
-                event.Check(win.autoComplete)
-            elif id == ID_AUTOCOMP_MAGIC:
-                event.Check(win.autoCompleteIncludeMagic)
-            elif id == ID_AUTOCOMP_SINGLE:
-                event.Check(win.autoCompleteIncludeSingle)
-            elif id == ID_AUTOCOMP_DOUBLE:
-                event.Check(win.autoCompleteIncludeDouble)
-            elif id == ID_CALLTIPS_SHOW:
-                event.Check(win.autoCallTip)
-            elif id == ID_WRAP:
-                event.Check(win.GetWrapMode())
-            else:
-                event.Enable(False)
-        except AttributeError:
-            # This menu option is not supported in the current context.
-            event.Enable(False)

wxPython/wxPython/py/images.py

@@ -1,71 +0,0 @@
-#----------------------------------------------------------------------
-# This file was generated by ../scripts/img2py
-#
-from wxPython.wx import wxImageFromStream, wxBitmapFromImage
-from wxPython.wx import wxEmptyIcon
-import cStringIO
-
-
-def getPyCrustData():
-    return \
-'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
-\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x04\
-\x95IDATx\x9c\xed\x97?lSG\x1c\xc7?\x97\x98\xd8Q\xa3\xdeY\xa2j\x06\xa4\xf7"QJ\
-\xbb<3@\x01\xa9\xc2\x0c\xa8!\x1d\x1c6\xcaB\xa8D[uI2\xf4\x8f\xe8\x103\xb4\xa2\
-,5\x0b\x03\x032C\xab\xc0\x92dh:t\xc0)*E\xcd@<Q\x01Rl\t\xd4D\xaa\xe4{R\xd0{&\
-\xa5\xd7\xe1\xfc\xec\xe7\xfciR\x08e\xe9O\xb2\xee|\xfe\xbd\xfb}~\xdf\xdf\xbd\
-\xbb\xb3PJ\xf1"\xad\xe3\x85F\xff\x1f\xe0y\x03h\xad\xcdA\xc7~\xb4\xd6f-\x9f\
-\xc4\xf3\x0c>Y\x1c#\x97\xddCUk\xf4B\x8d3\x9f\x8d\x9a\x9bU%\xe2~b\xab\xdf\x82\
-\x83N+\xd3\xe92\\\x1f\xcf\x93\xdd\x9f\xa1\xaa5\x95\xf9\n\xe7\xf3y\xe2\x10[V\
-\x82H\xe6\xd3G\x1dN\xf7\xc3\xa7\xc7a\xc0\x83\xc3\xc7\xf3\xcc\xcc\xcd\xe3(\
-\x85\xdb\xe7\xf2\xc9\xe8X\x1b\xe43+\x10\xd5\xb6\x94\x87Z\xe8\x90NU\x91I@\x00\
-\x06\xbe\x18\xb7J\x98\xca$`\x98\xb9]&{,\x8fRV\x85\xa7V@k\x9bq)o\x83+\t\xe9T\
-\xd5f\x95\x02\x91\xb4~_\r\xd9\xb6\xbaP\x03\x04n\x9f\xcbDa\xb8\t\xfe\xaf\x17a\
-<\xe3\xc8\x94lo\x9b\xd6\xa8\xf4\x80\x07\xb7o\xcd\xe0\x0c\x0e\xa2R\x8a\xb4\
-\x93n\xbal\x1a`e\xe0U\xc1\xd6\xb0\xb8\n\x99\x91"\x93\xaf\xba\xe4\x0ed\xda|6,\
-\x81\xd6\xda\x9c|\xab]\xea\xcd\x04\x8f\x9b\t\xad\nz\xa1\x02\x80\xdb\xe7R\x1a\
-\xcf\xa3\xb56\xeb\x02D5\x9e\xf8\xdc\xe1T\xff\xd3\x05\x8e\x82\x83U\xe1Z\xb1\
-\x18\x9b\xbf\x06\xacQ\x82H\xea\x01/Z@Ut\x08R\xb4$}\x16\xd3\x81A&%\xde\xee\
-\xbev\x80x\xe0]{\xb2\x1cR\xa5\xe6C*\xb5\xf1\xc4Q\xa6"e\xfbQ\x1b\x8dE\xe6\x87\
->\xaa[Q\xadi\x0b\xb0r\x8f\x9e.\xc3t\xb9\xc4]\xaf5\xf6\xfe\xdb\xddt&\x02\xfa\
-\x9c\xf5\x01\xe2A\xa2\xbeX\x01>]ntR\x12\xe3[\x00\x01\x98\x89\x11[_\xed\xafn\
-\xab\x81U\xa0\xe7I7\x00\x97o\x04\xcd\x89\x06<;\xe9\x80\x07]i\x97\xc17\x1f\
-\xd2\xd3\x91`\xe9\xaf?\x01p^Y\x06Z\n\xfau8?a\xfb]i\x97\xec\xa1\x8c\x05(|\xd8\
-N\xba\xb3\xab\x87\xfb\x8f\x97\xd8\xd9\xd5\x03\xc0\xfd\xc7K\xec\xd8\xd6\xdd\
-\xfc\xfd\xc1r\xd0\xf4\x01\xda~\x03H\xf4\x04\xd4j :\xb75\xc7\xae\xfd\xbcLW\
-\xda\xa5\xf0M\x1e\t\xcc\xcc\xcdq\xa9P@\x8c\xf5fL\xdaHF\x16g\x9a\x19\xad\xcc\
-\xee\xcb\xa3\n\xad\xa1\xda\xf1\x08\xef\xe5\x97x\xf8\xc8f\xf8\xc7\x93:\xdb;\
-\x93M\xc8\x08j\xc7\xb6n\x1e,\x07m`\x97o\x04|;>\xd1T\xc4\x17\x8a\x13\xb9\xc3\
-\x88\x01\x0fs\xa4\x9cc}\xf3A\x190\x82\x1f\xddR{-\x1bV\xfc\xd8f\xba\xbd3\xd9\
-\x06\x15\x07\xbb\xf8\xd3\x12\xdf]-"\x93\xb2\xb1C*\xde\xcd\x1d\xde\xccN(\xc1\
-\xae\x17"\xd0#+<j\x17m{\xcd\x9bj\x00.\xaf\xf0Xb\xb8\xdfA\xa6\x14\x18\x03\x06\
-\xb4o\xcf\x8d\xc4\xbervc\x86M\xdaz\x80\x00\x95T\x19?\xd0 @&%~c\xbc\xe3W\xaf\
-\xb4e\x00\xffh\xc6@\xbd\x11\xbc\xde\x1a\xfe\xef.\xa5\xa2q4\n0\x81\xad\xe9\
-\xae7<\x12\xaf\xf5\xc2hy\xaa\xe97\x9cS\\\x98\xb2\x0e\x03\xb1\xcdhW\xdaC\x1a\
-\xa0\xa2\xa0\x0e"\x14`\xb0Y\x85\x1b\x1f\x12\xaa7\x03)\xd9\x84\xa8\xccW\xb8{\
-\xa7L\xe2\xde\x02\x94\xc6Gp_\xcf\x80\x90\x98\xd0g\xf4\xac\x82Pc\x82\x1a\xd5\
-\x10\x08}&\xa7J\xcc\xde.1]m\x80\xf6+\xee\xfd\xae\x9bo\xc4\xf0;\x80\xef\x90\
-\x0e\x04\x06`Q!\x02\x05\xc2 \xb5\xc2\x95\x15d\xb4C&[\xf7\xd2\x04\x80\xbb\xdb\
-\x9e\xd1\x8e\x02\x90\xd8\xd4$ I\x87\x80\xf1\xf1\xdc!4\xc3\x88\x94}\xd8,TH\
-\xbb.5m\xf0C\x9f3\x1f\r\x01\x96.\x82\x1a9\xe9Q\xb8\xd2\xf8\xf25\x0c\xbe\xe7#\
-\x92\x12\x1d[\x03\t\x00E\xf4\xa6\t\xaaZ7`$\x18\x90\xf8\xf8\x80JK\x94\xa1\x01\
-\x07\xb8\x0e~X\xc3\xed\x16\xf8)\xf8~j\x12B\rI\x89_\xf7!0 \x04\xf9Q\xc0\x18\
-\x0c\xd1i\xea\x13\xb7\x04\xc0\x89\x93C\xabj\xb6\xf7@\x96\xd9_J|0:\x86R\n\xb7\
-\xd7@\xaa%\x9d\xa3$\xba.\x90RA]\xe3\x87\x1a\x89\xdd\xefeR\xc2\x1a\'\xa8\x1f\
-\x82\x0e-@m\xd1\xde\x076\xbc\x15\x97~(\x9a\x89b\x9e\xd9[s\xab!\xf7g\xd6\x1c\
-\x8f\xdb\xbel\x8e\xa1S\xc7\xda\xc6\xe6\xee\xccs\xe9\xdcYnV\x95\xd8\xf2?&q+\
-\x9c\x1b1\xf3\xbf\xcd3{\xfdJ\xdb\xf8\xde\xfd\x19.\\\xad\x08\x80\xbf\x01\xd1\
-\x86\xfa\x8b\xc7\xc0\xc8\xb7\x00\x00\x00\x00IEND\xaeB`\x82' 
-
-def getPyCrustBitmap():
-    return wxBitmapFromImage(getPyCrustImage())
-
-def getPyCrustImage():
-    stream = cStringIO.StringIO(getPyCrustData())
-    return wxImageFromStream(stream)
-
-def getPyCrustIcon():
-    icon = wxEmptyIcon()
-    icon.CopyFromBitmap(getPyCrustBitmap())
-    return icon
-

wxPython/wxPython/py/interpreter.py

@@ -1,125 +0,0 @@
-"""PyCrust Interpreter executes Python commands."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-import sys
-from code import InteractiveInterpreter
-import dispatcher
-import introspect
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Interpreter(InteractiveInterpreter):
-    """PyCrust Interpreter based on code.InteractiveInterpreter."""
-    
-    revision = __revision__
-    
-    def __init__(self, locals=None, rawin=None, 
-                 stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
-        """Create an interactive interpreter object."""
-        InteractiveInterpreter.__init__(self, locals=locals)
-        self.stdin = stdin
-        self.stdout = stdout
-        self.stderr = stderr
-        if rawin:
-            import __builtin__
-            __builtin__.raw_input = rawin
-            del __builtin__
-        copyright = 'Type "help", "copyright", "credits" or "license"'
-        copyright += ' for more information.'
-        self.introText = 'Python %s on %s%s%s' % \
-                         (sys.version, sys.platform, os.linesep, copyright)
-        try:
-            sys.ps1
-        except AttributeError:
-            sys.ps1 = '>>> '
-        try:
-            sys.ps2
-        except AttributeError:
-            sys.ps2 = '... '
-        self.more = 0
-        # List of lists to support recursive push().
-        self.commandBuffer = []
-        self.startupScript = os.environ.get('PYTHONSTARTUP')
-
-    def push(self, command):
-        """Send command to the interpreter to be executed.
-        
-        Because this may be called recursively, we append a new list
-        onto the commandBuffer list and then append commands into
-        that.  If the passed in command is part of a multi-line
-        command we keep appending the pieces to the last list in
-        commandBuffer until we have a complete command. If not, we
-        delete that last list."""
-        command = str(command)  # In case the command is unicode.
-        if not self.more:
-            try: del self.commandBuffer[-1]
-            except IndexError: pass
-        if not self.more: self.commandBuffer.append([])
-        self.commandBuffer[-1].append(command)
-        source = '\n'.join(self.commandBuffer[-1])
-        more = self.more = self.runsource(source)
-        dispatcher.send(signal='Interpreter.push', sender=self,
-                        command=command, more=more, source=source)
-        return more
-        
-    def runsource(self, source):
-        """Compile and run source code in the interpreter."""
-        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
-        sys.stdin, sys.stdout, sys.stderr = \
-                   self.stdin, self.stdout, self.stderr
-        more = InteractiveInterpreter.runsource(self, source)
-        # If sys.std* is still what we set it to, then restore it.
-        # But, if the executed source changed sys.std*, assume it was
-        # meant to be changed and leave it. Power to the people.
-        if sys.stdin == self.stdin:
-            sys.stdin = stdin
-        if sys.stdout == self.stdout:
-            sys.stdout = stdout
-        if sys.stderr == self.stderr:
-            sys.stderr = stderr
-        return more
-        
-    def getAutoCompleteKeys(self):
-        """Return list of auto-completion keycodes."""
-        return [ord('.')]
-
-    def getAutoCompleteList(self, command='', *args, **kwds):
-        """Return list of auto-completion options for a command.
-        
-        The list of options will be based on the locals namespace."""
-        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
-        sys.stdin, sys.stdout, sys.stderr = \
-                   self.stdin, self.stdout, self.stderr
-        l = introspect.getAutoCompleteList(command, self.locals,
-                                           *args, **kwds)
-        sys.stdin, sys.stdout, sys.stderr = stdin, stdout, stderr
-        return l
-
-    def getCallTip(self, command='', *args, **kwds):
-        """Return call tip text for a command.
-        
-        Call tip information will be based on the locals namespace."""
-        return introspect.getCallTip(command, self.locals, *args, **kwds)
-
-
-class InterpreterAlaCarte(Interpreter):
-    """PyCrustAlaCarte Demo Interpreter."""
-    
-    def __init__(self, locals, rawin, stdin, stdout, stderr, 
-                 ps1='main prompt', ps2='continuation prompt'):
-        """Create an interactive interpreter object."""
-        Interpreter.__init__(self, locals=locals, rawin=rawin, 
-                             stdin=stdin, stdout=stdout, stderr=stderr)
-        sys.ps1 = ps1
-        sys.ps2 = ps2
-
-   

wxPython/wxPython/py/introspect.py

@@ -1,360 +0,0 @@
-"""Provides a variety of introspective-type support functions for
-things like call tips and command auto completion."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from __future__ import nested_scopes
-
-import cStringIO
-import inspect
-import sys
-import tokenize
-import types
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-def getAutoCompleteList(command='', locals=None, includeMagic=1, 
-                        includeSingle=1, includeDouble=1):
-    """Return list of auto-completion options for command.
-    
-    The list of options will be based on the locals namespace."""
-    attributes = []
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='.')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        pass
-    else:
-        attributes = getAttributeNames(object, includeMagic, 
-                                       includeSingle, includeDouble)
-    return attributes
-    
-def getAttributeNames(object, includeMagic=1, includeSingle=1,
-                      includeDouble=1):
-    """Return list of unique attributes, including inherited, for object."""
-    attributes = []
-    dict = {}
-    if not hasattrAlwaysReturnsTrue(object):
-        # Add some attributes that don't always get picked up.  If
-        # they don't apply, they'll get filtered out at the end.
-        attributes += ['__bases__', '__class__', '__dict__', '__name__', 
-                       'func_closure', 'func_code', 'func_defaults', 
-                       'func_dict', 'func_doc', 'func_globals', 'func_name']
-    if includeMagic:
-        try: attributes += object._getAttributeNames()
-        except: pass
-    # Get all attribute names.
-    attrdict = getAllAttributeNames(object)
-    for attrlist in attrdict.values():
-        attributes += attrlist
-    # Remove duplicates from the attribute list.
-    for item in attributes:
-        dict[item] = None
-    attributes = dict.keys()
-    attributes.sort(lambda x, y: cmp(x.upper(), y.upper()))
-    if not includeSingle:
-        attributes = filter(lambda item: item[0]!='_' \
-                            or item[1]=='_', attributes)
-    if not includeDouble:
-        attributes = filter(lambda item: item[:2]!='__', attributes)
-    # Make sure we haven't picked up any bogus attributes somehow.
-    attributes = [attribute for attribute in attributes \
-                  if hasattr(object, attribute)]
-    return attributes
-
-def hasattrAlwaysReturnsTrue(object):
-    return hasattr(object, 'bogu5_123_aTTri8ute')
-
-def getAllAttributeNames(object):
-    """Return dict of all attributes, including inherited, for an object.
-    
-    Recursively walk through a class and all base classes.
-    """
-    attrdict = {}  # (object, technique, count): [list of attributes]
-    # !!!
-    # Do Not use hasattr() as a test anywhere in this function,
-    # because it is unreliable with remote objects: xmlrpc, soap, etc.
-    # They always return true for hasattr().
-    # !!!
-    try:
-        # Yes, this can fail if object is an instance of a class with
-        # __str__ (or __repr__) having a bug or raising an
-        # exception. :-(
-        key = str(object)
-    except:
-        key = 'anonymous'
-    # Wake up sleepy objects - a hack for ZODB objects in "ghost" state.
-    wakeupcall = dir(object)
-    del wakeupcall
-    # Get attributes available through the normal convention.
-    attributes = dir(object)
-    attrdict[(key, 'dir', len(attributes))] = attributes
-    # Get attributes from the object's dictionary, if it has one.
-    try:
-        attributes = object.__dict__.keys()
-        attributes.sort()
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        attrdict[(key, '__dict__', len(attributes))] = attributes
-    # For a class instance, get the attributes for the class.
-    try:
-        klass = object.__class__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if klass is object:
-            # Break a circular reference. This happens with extension
-            # classes.
-            pass
-        else:
-            attrdict.update(getAllAttributeNames(klass))
-    # Also get attributes from any and all parent classes.
-    try:
-        bases = object.__bases__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if isinstance(bases, types.TupleType):
-            for base in bases:
-                if type(base) is types.TypeType:
-                    # Break a circular reference. Happens in Python 2.2.
-                    pass
-                else:
-                    attrdict.update(getAllAttributeNames(base))
-    return attrdict
-
-def getCallTip(command='', locals=None):
-    """For a command, return a tuple of object name, argspec, tip text.
-    
-    The call tip information will be based on the locals namespace."""
-    calltip = ('', '', '')  # object name, argspec, tip text.
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='(')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        return calltip
-    name = ''
-    object, dropSelf = getBaseObject(object)
-    try:
-        name = object.__name__
-    except AttributeError:
-        pass
-    tip1 = ''
-    argspec = ''
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        pass
-    elif inspect.isfunction(object):
-        # tip1 is a string like: "getCallTip(command='', locals=None)"
-        argspec = apply(inspect.formatargspec, inspect.getargspec(object))
-        if dropSelf:
-            # The first parameter to a method is a reference to an
-            # instance, usually coded as "self", and is usually passed
-            # automatically by Python; therefore we want to drop it.
-            temp = argspec.split(',')
-            if len(temp) == 1:  # No other arguments.
-                argspec = '()'
-            else:  # Drop the first argument.
-                argspec = '(' + ','.join(temp[1:]).lstrip()
-        tip1 = name + argspec
-    doc = ''
-    if callable(object):
-        doc = inspect.getdoc(object)
-    if doc:
-        # tip2 is the first separated line of the docstring, like:
-        # "Return call tip text for a command."
-        # tip3 is the rest of the docstring, like:
-        # "The call tip information will be based on ... <snip>
-        firstline = doc.split('\n')[0].lstrip()
-        if tip1 == firstline:
-            tip1 = ''
-        else:
-            tip1 += '\n\n'
-        docpieces = doc.split('\n\n')
-        tip2 = docpieces[0]
-        tip3 = '\n\n'.join(docpieces[1:])
-        tip = '%s%s\n\n%s' % (tip1, tip2, tip3)
-    else:
-        tip = tip1
-    calltip = (name, argspec[1:-1], tip.strip())
-    return calltip
-
-def getRoot(command, terminator=None):
-    """Return the rightmost root portion of an arbitrary Python command.
-    
-    Return only the root portion that can be eval()'d without side
-    effects.  The command would normally terminate with a '(' or
-    '.'. The terminator and anything after the terminator will be
-    dropped."""
-    command = command.split('\n')[-1]
-    if command.startswith(sys.ps2):
-        command = command[len(sys.ps2):]
-    command = command.lstrip()
-    command = rtrimTerminus(command, terminator)
-    tokens = getTokens(command)
-    if not tokens:
-        return ''
-    if tokens[-1][0] is tokenize.ENDMARKER:
-        # Remove the end marker.
-        del tokens[-1]
-    if not tokens:
-        return ''
-    if terminator == '.' and \
-           (tokens[-1][1] <> '.' or tokens[-1][0] is not tokenize.OP):
-        # Trap decimals in numbers, versus the dot operator.
-        return ''
-    else:
-        # Strip off the terminator.
-        if terminator and command.endswith(terminator):
-            size = 0 - len(terminator)
-            command = command[:size]
-    command = command.rstrip()
-    tokens = getTokens(command)
-    tokens.reverse()
-    line = ''
-    start = None
-    prefix = ''
-    laststring = '.'
-    emptyTypes = ('[]', '()', '{}')
-    for token in tokens:
-        tokentype = token[0]
-        tokenstring = token[1]
-        line = token[4]
-        if tokentype is tokenize.ENDMARKER:
-            continue
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        and laststring != '.':
-            # We've reached something that's not part of the root.
-            if prefix and line[token[3][1]] != ' ':
-                # If it doesn't have a space after it, remove the prefix.
-                prefix = ''
-            break
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        or (tokentype is tokenize.OP and tokenstring == '.'):
-            if prefix:
-                # The prefix isn't valid because it comes after a dot.
-                prefix = ''
-                break
-            else:
-                # start represents the last known good point in the line.
-                start = token[2][1]
-        elif len(tokenstring) == 1 and tokenstring in ('[({])}'):
-            # Remember, we're working backwords.
-            # So prefix += tokenstring would be wrong.
-            if prefix in emptyTypes and tokenstring in ('[({'):
-                # We've already got an empty type identified so now we
-                # are in a nested situation and we can break out with
-                # what we've got.
-                break
-            else:
-                prefix = tokenstring + prefix
-        else:
-            # We've reached something that's not part of the root.
-            break
-        laststring = tokenstring
-    if start is None:
-        start = len(line)
-    root = line[start:]
-    if prefix in emptyTypes:
-        # Empty types are safe to be eval()'d and introspected.
-        root = prefix + root
-    return root    
-
-def getTokens(command):
-    """Return list of token tuples for command."""
-    command = str(command)  # In case the command is unicode, which fails.
-    f = cStringIO.StringIO(command)
-    # tokens is a list of token tuples, each looking like: 
-    # (type, string, (srow, scol), (erow, ecol), line)
-    tokens = []
-    # Can't use list comprehension:
-    #   tokens = [token for token in tokenize.generate_tokens(f.readline)]
-    # because of need to append as much as possible before TokenError.
-    try:
-##        This code wasn't backward compatible with Python 2.1.3.
-##
-##        for token in tokenize.generate_tokens(f.readline):
-##            tokens.append(token)
-
-        # This works with Python 2.1.3 (with nested_scopes).
-        def eater(*args):
-            tokens.append(args)
-        tokenize.tokenize_loop(f.readline, eater)
-    except tokenize.TokenError:
-        # This is due to a premature EOF, which we expect since we are
-        # feeding in fragments of Python code.
-        pass
-    return tokens    
-
-def rtrimTerminus(command, terminator=None):
-    """Return command minus anything that follows the final terminator."""
-    if terminator:
-        pieces = command.split(terminator)
-        if len(pieces) > 1:
-            command = terminator.join(pieces[:-1]) + terminator
-    return command
-
-def getBaseObject(object):
-    """Return base object and dropSelf indicator for an object."""
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        dropSelf = 0
-    elif inspect.ismethod(object):
-        # Get the function from the object otherwise
-        # inspect.getargspec() complains that the object isn't a
-        # Python function.
-        try:
-            if object.im_self is None:
-                # This is an unbound method so we do not drop self
-                # from the argspec, since an instance must be passed
-                # as the first arg.
-                dropSelf = 0
-            else:
-                dropSelf = 1
-            object = object.im_func
-        except AttributeError:
-            dropSelf = 0
-    elif inspect.isclass(object):
-        # Get the __init__ method function for the class.
-        constructor = getConstructor(object)
-        if constructor is not None:
-            object = constructor
-            dropSelf = 1
-        else:
-            dropSelf = 0
-    elif callable(object):
-        # Get the __call__ method instead.
-        try:
-            object = object.__call__.im_func
-            dropSelf = 1
-        except AttributeError:
-            dropSelf = 0
-    else:
-        dropSelf = 0
-    return object, dropSelf
-
-def getConstructor(object):
-    """Return constructor for class object, or None if there isn't one."""
-    try:
-        return object.__init__.im_func
-    except AttributeError:
-        for base in object.__bases__:
-            constructor = getConstructor(base)
-            if constructor is not None:
-                return constructor
-    return None

wxPython/wxPython/py/pseudo.py

@@ -1,107 +0,0 @@
-"""Provides a variety of classes to create pseudo keywords and pseudo files."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class PseudoKeyword:
-    """A callable class that calls a method passed as a parameter.
-
-    Good for creating a pseudo keyword in the python runtime
-    environment. The keyword is really an object that has a repr()
-    that calls itself which calls the method that was passed in the
-    init of the object. All this just to avoid having to type in the
-    closing parens on a method. So, for example:
-
-        >>> quit = PseudoKeyword(SomeObject.someMethod)
-        >>> quit
-
-    SomeObject.someMethod gets executed as if it had been called
-    directly and the user didn't have to type the parens, like
-    'quit()'. This technique is most applicable for pseudo keywords
-    like quit, exit and help.
-
-    If SomeObject.someMethod can take parameters, they can still be
-    passed by using the keyword in the traditional way with parens."""
-
-    def __init__(self, method):
-        """Create a callable object that executes method when called."""
-
-        if callable(method):
-            self.method = method
-        else:
-            raise ValueError, 'method must be callable'
-
-    def __call__(self, *args, **kwds):
-        self.method(*args, **kwds)
-
-    def __repr__(self):
-        self()
-        return ''
-
-
-class PseudoFile:
-
-    def __init__(self):
-        """Create a file-like object."""
-        pass
-
-    def readline(self):
-        pass
-
-    def write(self, s):
-        pass
-
-    def writelines(self, l):
-        map(self.write, l)
-
-    def flush(self):
-        pass
-
-    def isatty(self):
-        pass
-
-
-class PseudoFileIn(PseudoFile):
-
-    def __init__(self, readline, readlines=None):
-        if callable(readline):
-            self.readline = readline
-        else:
-            raise ValueError, 'readline must be callable'
-        if callable(readlines):
-            self.readlines = readlines
-
-    def isatty(self):
-        return 1
-        
-        
-class PseudoFileOut(PseudoFile):
-
-    def __init__(self, write):
-        if callable(write):
-            self.write = write
-        else:
-            raise ValueError, 'write must be callable'
-
-    def isatty(self):
-        return 1
-
-
-class PseudoFileErr(PseudoFile):
-
-    def __init__(self, write):
-        if callable(write):
-            self.write = write
-        else:
-            raise ValueError, 'write must be callable'
-
-    def isatty(self):
-        return 1

wxPython/wxPython/py/tests/test_interpreter.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import interpreter
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = interpreter
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.Interpreter)
-        self.assert_(module.Interpreter.push)
-        self.assert_(module.Interpreter.runsource)
-        self.assert_(module.Interpreter.getAutoCompleteList)
-        self.assert_(module.Interpreter.getCallTip)
-        self.assert_(module.InterpreterAlaCarte)
-
-
-class InterpreterTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.output = ''
-        self.i = interpreter.Interpreter(stdout=self)
-
-    def write(self, text):
-        """Capture output from self.i.push()."""
-        self.output += text
-
-    def tearDown(self):
-        self.output = ''
-        self.i = None
-        del self.i
-
-    def test_more(self):
-        self.assertEqual(self.i.push('dir()'), 0)
-        self.assertEqual(self.i.push('for n in range(3):'), 1)
-
-    def test_push(self):
-        values = (
-        ('dir', '<built-in function dir>'),
-        ('dir()', "['__builtins__', '__doc__', '__name__']"),
-        ('2 + 2', '4'),
-        ('d = {}', ''),
-        ('d', '{}'),
-        ('del d', ''),
-        ('len([4,5,6])', '3'),
-        )
-        for input, output in values:
-            if output: output += '\n'
-            self.i.push(input)
-            self.assertEqual(self.output, output)
-            self.output = ''
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/test_introspect.py

@@ -1,862 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import introspect
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = introspect
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.getAllAttributeNames)
-        self.assert_(module.getAttributeNames)
-        self.assert_(module.getAutoCompleteList)
-        self.assert_(module.getBaseObject)
-        self.assert_(module.getCallTip)
-        self.assert_(module.getConstructor)
-        self.assert_(module.getRoot)
-        self.assert_(module.rtrimTerminus)
-
-
-class RtrimTerminusTestCase(unittest.TestCase):
-
-    def test_rtrimTerminus(self):
-        values = (
-            ('', '', ''),
-            ('', None, ''),
-            ('', '.', ''),
-            ('', '(', ''),
-            
-            ('.', '', '.'),
-            ('.', None, '.'),
-            ('.', '.', '.'),
-            ('.', '(', '.'),
-            
-            ('(', '', '('),
-            ('(', None, '('),
-            ('(', '.', '('),
-            ('(', '(', '('),
-            
-            ('spam', '', 'spam'),
-            ('spam', None, 'spam'),
-            ('spam', '.', 'spam'),
-            ('spam', '(', 'spam'),
-            
-            ('spam.', '', 'spam.'),
-            ('spam.', None, 'spam.'),
-            ('spam.', '.', 'spam.'),
-            ('spam.', '(', 'spam.'),
-            
-            ('spam(', '', 'spam('),
-            ('spam(', None, 'spam('),
-            ('spam(', '.', 'spam('),
-            ('spam(', '(', 'spam('),
-            
-            ('spam.eggs', '.', 'spam.'),
-            ('spam.eggs.', '.', 'spam.eggs.'),
-            ('spam.eggs(', '(', 'spam.eggs('),
-            ('spam.eggs.', '(', 'spam.eggs.'),
-            ('spam.eggs(', '.', 'spam.'),
-            
-            ('x = spam.', '.', 'x = spam.'),
-            ('x = spam.eggs', '.', 'x = spam.'),
-            ('x = spam.eggs.', '.', 'x = spam.eggs.'),
-            ('x = spam.eggs(', '(', 'x = spam.eggs('),
-        )
-        for input, terminator, output in values:
-            result = introspect.rtrimTerminus(input, terminator)
-            self.assertEqual(result, output,
-                             ':in: %r :t: %r :out: %r :result: %r' %
-                             (input, terminator, output, result))
-
-
-class GetRootTestCase(unittest.TestCase):
-
-    def _checkRoot(self, input, terminator, output):
-        root = introspect.getRoot(command=input, terminator=terminator)
-        self.assertEqual(root, output,
-                         ':in: %r :t: %r :out: %r :root: %r' %
-                         (input, terminator, output, root))
-
-    def test_getRoot(self):
-        values = (
-            ('', '', ''),
-            ('', None, ''),
-            ('', '.', ''),
-            ('', '(', ''),
-            
-            ('.', '', '.'),
-            ('.', None, '.'),
-            ('.', '.', ''),
-            ('.', '(', '.'),
-            
-            ('(', '', ''),
-            ('(', None, ''),
-            ('(', '.', ''),
-            ('(', '(', ''),
-            
-            ('spam', '', 'spam'),
-            ('spam', None, 'spam'),
-            ('spam', '.', ''),
-            ('spam', '(', 'spam'),
-            
-            ('spam.', '', 'spam.'),
-            ('spam.', None, 'spam.'),
-            ('spam.', '.', 'spam'),
-            ('spam.', '(', 'spam.'),
-            
-            ('spam(', '', ''),
-            ('spam(', None, ''),
-            ('spam(', '.', ''),
-            ('spam(', '(', 'spam'),
-            
-            ('spam.eggs', '.', 'spam'),
-            ('spam.eggs.', '.', 'spam.eggs'),
-            ('spam.eggs(', '(', 'spam.eggs'),
-            ('spam.eggs.', '(', 'spam.eggs.'),
-            ('spam.eggs(', '.', 'spam'),
-            
-            ('x = spam.', '.', 'spam'),
-            ('x = spam.eggs', '.', 'spam'),
-            ('x = spam.eggs.', '.', 'spam.eggs'),
-            ('x = spam.eggs(', '(', 'spam.eggs'),
-
-            ('for n in range(3):\n    d.', '.', 'd'),
-            ('for n in range(3):\n...    d.', '.', 'd'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-    def test_getRoot_Advanced(self):
-        values = (
-            ('spam_', '', 'spam_'),
-            ('spam_', None, 'spam_'),
-            ('spam_', '.', ''),
-            ('spam_', '(', 'spam_'),
-            
-            ('_spam', '', '_spam'),
-            ('_spam', None, '_spam'),
-            ('_spam', '.', ''),
-            ('_spam', '(', '_spam'),
-            
-            ('spam_eggs', '', 'spam_eggs'),
-            ('spam_eggs', None, 'spam_eggs'),
-            ('spam_eggs', '.', ''),
-            ('spam_eggs', '(', 'spam_eggs'),
-            
-            ('spam123', '', 'spam123'),
-            ('spam123', None, 'spam123'),
-            ('spam123', '.', ''),
-            ('spam123', '(', 'spam123'),
-
-            ('spam_123', '', 'spam_123'),
-            ('spam_123', None, 'spam_123'),
-            ('spam_123', '.', ''),
-            ('spam_123', '(', 'spam_123'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-## The original intent was to detect when we were inside a string.
-## That has proven to be very difficult, for little benefit.
-## The fact that autocomplete or calltips might be triggered inside
-## a string is not a big deal. Sometimes it is even helpful.
-
-##    def test_getRoot_InsideStrings(self):
-##        values = (
-##            ('x = ".', '.', ''),
-##            ("x = '.", '.', ''),
-##            ('x = """.', '.', ''),
-##            ("x = '''.", '.', ''),
-##
-##            ('x = "(', '(', ''),
-##            ("x = '(", '(', ''),
-##            ('x = """(', '(', ''),
-##            ("x = '''(", '(', ''),
-##
-##            ('x = "spam', '.', ''),
-##            ('x = "spam.', '.', ''),
-##            ("x = 'spam.", '.', ''),
-##            ('x = """spam.', '.', ''),
-##            ("x = '''spam.", '.', ''),
-##            
-##            ('x = "spam', '(', ''),
-##            ('x = "spam(', '(', ''),
-##            ("x = 'spam(", '(', ''),
-##            ('x = """spam(', '(', ''),
-##            ("x = '''spam(", '(', ''),
-##            
-##            ('x = "spam.eggs.', '.', ''),
-##            ("x = 'spam.eggs.", '.', ''),
-##            ('x = """spam.eggs.', '.', ''),
-##            ("x = '''spam.eggs.", '.', ''),
-##            
-##            ('x = "spam.eggs(', '(', ''),
-##            ("x = 'spam.eggs(", '(', ''),
-##            ('x = """spam.eggs(', '(', ''),
-##            ("x = '''spam.eggs(", '(', ''),
-##        )
-##        for input, terminator, output in values:
-##            self._checkRoot(input, terminator, output)
-
-    def test_getRoot_EmptyTypes(self):
-        values = (
-            ("''.", '.', "''"),
-            ('"".', '.', '""'),
-            ('"""""".', '.', '""""""'),
-            ("''''''.", '.', "''''''"),
-
-            ('[].', '.', '[]'),
-            ('().', '.', '()'),
-            ('{}.', '.', '{}'),
-            
-            ('[](', '(', '[]'),
-            ('()(', '(', '()'),
-            ('{}(', '(', '{}'),
-            
-            ("x = ''.", '.', "''"),
-            ('x = "".', '.', '""'),
-            ('x = """""".', '.', '""""""'),
-            ("x = ''''''.", '.', "''''''"),
-
-            ('x = [].', '.', '[]'),
-            ('x = ().', '.', '()'),
-            ('x = {}.', '.', '{}'),
-            
-            ('x = [](', '(', '[]'),
-            ('x = ()(', '(', '()'),
-            ('x = {}(', '(', '{}'),
-
-            ('print [].', '.', '[]'),
-            ('print ().', '.', '()'),
-            ('print {}.', '.', '{}'),
-            
-            ('print [](', '(', '[]'),
-            ('print ()(', '(', '()'),
-            ('print {}(', '(', '{}'),
-
-            ("''.attr.", '.', "''.attr"),
-            ('"".attr.', '.', '"".attr'),
-            ('"""""".attr.', '.', '"""""".attr'),
-            ("''''''.attr.", '.', "''''''.attr"),
-
-            ('[].attr.', '.', '[].attr'),
-            ('().attr.', '.', '().attr'),
-            ('{}.attr.', '.', '{}.attr'),
-            
-            ('[].attr(', '(', '[].attr'),
-            ('().attr(', '(', '().attr'),
-            ('{}.attr(', '(', '{}.attr'),
-
-            ('spam().', '.', ''),
-            ('spam_().', '.', ''),
-            ('spam5().', '.', ''),
-            ('spam[]().', '.', ''),
-            ('spam()[].', '.', ''),
-            ('spam[]{}.', '.', ''),
-
-            ("spam(''.", '.', "''"),
-            ('spam("".', '.', '""'),
-            ('spam("""""".', '.', '""""""'),
-            ("spam(''''''.", '.', "''''''"),
-
-            ('spam([].', '.', '[]'),
-            ('spam(().', '.', '()'),
-            ('spam({}.', '.', '{}'),
-            ('spam[[].', '.', '[]'),
-            ('spam[().', '.', '()'),
-            ('spam[{}.', '.', '{}'),
-            ('x = {[].', '.', '[]'),
-            ('x = {().', '.', '()'),
-            ('x = {{}.', '.', '{}'),
-
-            ('spam,[].', '.', '[]'),
-            ('spam+[].', '.', '[]'),
-            ('spam-[].', '.', '[]'),
-            ('spam*[].', '.', '[]'),
-            ('spam/[].', '.', '[]'),
-            ('spam=[].', '.', '[]'),
-            ('spam%[].', '.', '[]'),
-            ('spam<[].', '.', '[]'),
-            ('spam>[].', '.', '[]'),
-            ('spam&[].', '.', '[]'),
-            ('spam|[].', '.', '[]'),
-            ('spam^[].', '.', '[]'),
-            ('spam~[].', '.', '[]'),
-            ('spam:[].', '.', '[]'),
-
-            ('spam,().', '.', '()'),
-            ('spam+().', '.', '()'),
-            ('spam-().', '.', '()'),
-            ('spam*().', '.', '()'),
-            ('spam/().', '.', '()'),
-            ('spam=().', '.', '()'),
-            ('spam%().', '.', '()'),
-            ('spam<().', '.', '()'),
-            ('spam>().', '.', '()'),
-            ('spam&().', '.', '()'),
-            ('spam|().', '.', '()'),
-            ('spam^().', '.', '()'),
-            ('spam~().', '.', '()'),
-            ('spam:().', '.', '()'),
-
-            ('spam,{}.', '.', '{}'),
-            ('spam+{}.', '.', '{}'),
-            ('spam-{}.', '.', '{}'),
-            ('spam*{}.', '.', '{}'),
-            ('spam/{}.', '.', '{}'),
-            ('spam={}.', '.', '{}'),
-            ('spam%{}.', '.', '{}'),
-            ('spam<{}.', '.', '{}'),
-            ('spam>{}.', '.', '{}'),
-            ('spam&{}.', '.', '{}'),
-            ('spam|{}.', '.', '{}'),
-            ('spam^{}.', '.', '{}'),
-            ('spam~{}.', '.', '{}'),
-            ('spam:{}.', '.', '{}'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-
-# Support for GetBaseObjectTestCase and GetAttributeNamesTestCase.
-
-class Foo:
-    def __init__(self):
-        pass
-
-    def __del__(self):
-        pass
-
-    def _private(self):
-        pass
-
-class Bar:
-    pass
-
-class Spam:
-    def __call__(self):
-        pass
-
-    def foo(self):
-        pass
-
-    def bar(spam):
-        # It shouldn't matter what we call "self".
-        pass
-
-    def eggs(self):
-        pass
-
-def ham(eggs):
-    pass
-
-class GetBaseObjectTestCase(unittest.TestCase):
-
-    def test_getBaseObject(self):
-        spam = Spam()
-        eggs = Spam.eggs
-        listappend = [].append
-        spamda = lambda: None
-        values = (
-            ('spam', 'spam', 0),
-            (123, 123, 0),
-            (12.3, 12.3, 0),
-            ([], [], 0),
-            ((), (), 0),
-            ({}, {}, 0),
-            # Builtin function.
-            (len, len, 0),
-            # Builtin method.
-            (listappend, listappend, 0),
-            # User function.
-            (ham, ham, 0),
-            # Byte-compiled code.
-            (ham.func_code, ham.func_code, 0),
-            # Lambda.
-            (spamda, spamda, 0),
-            # Class with init.
-            (Foo, Foo.__init__.im_func, 1),
-            # Class with no init.
-            (Bar, Bar, 0),
-            # Bound method.
-            (spam.foo, spam.foo.im_func, 1),
-            # Bound method with self named something else (spam).
-            (spam.bar, spam.bar.im_func, 1),
-            # Unbound method. (Do not drop the self argument.)
-            (eggs, eggs.im_func, 0),
-            # Callable instance.
-            (spam, spam.__call__.im_func, 1),
-        )
-        for object, baseObject, dropSelf in values:
-            result = introspect.getBaseObject(object)
-            self.assertEqual(result, (baseObject, dropSelf))
-
-
-class GetAttributeTestCase(unittest.TestCase):
-    """Base class for other test case classes."""
-
-    def setUp(self):
-        self.values = (
-            '__abs__',
-            '__add__',
-            '__and__',
-            '__base__',
-            '__bases__',
-            '__basicsize__',
-            '__builtins__',
-            '__call__',
-            '__class__',
-            '__cmp__',
-            '__coerce__',
-            '__contains__',
-            '__del__',
-            '__delattr__',
-            '__delitem__',
-            '__delslice__',
-            '__dict__',
-            '__dictoffset__',
-            '__div__',
-            '__divmod__',
-            '__doc__',
-            '__eq__',
-            '__file__',
-            '__flags__',
-            '__float__',
-            '__floordiv__',
-            '__ge__',
-            '__get__',
-            '__getattr__',
-            '__getattribute__',
-            '__getitem__',
-            '__getslice__',
-            '__gt__',
-            '__hash__',
-            '__hex__',
-            '__iadd__',
-            '__imul__',
-            '__init__',
-            '__int__',
-            '__invert__',
-            '__itemsize__',
-            '__iter__',
-            '__le__',
-            '__len__',
-            '__long__',
-            '__lshift__',
-            '__lt__',
-            '__mod__',
-            '__module__',
-            '__mro__',
-            '__mul__',
-            '__name__',
-            '__ne__',
-            '__neg__',
-            '__new__',
-            '__nonzero__',
-            '__oct__',
-            '__or__',
-            '__path__',
-            '__pos__',
-            '__pow__',
-            '__radd__',
-            '__rand__',
-            '__rdiv__',
-            '__rdivmod__',
-            '__reduce__',
-            '__repr__',
-            '__rfloordiv__',
-            '__rlshift__',
-            '__rmod__',
-            '__rmul__',
-            '__ror__',
-            '__rpow__',
-            '__rrshift__',
-            '__rshift__',
-            '__rsub__',
-            '__rtruediv__',
-            '__rxor__',
-            '__self__',
-            '__setattr__',
-            '__setitem__',
-            '__setslice__',
-            '__str__',
-            '__sub__',
-            '__subclasses__',
-            '__truediv__',
-            '__warningregistry__',
-            '__weakrefoffset__',
-            '__xor__',
-            'append',
-            'capitalize',
-            'center',
-            'clear',
-            'close',
-            'closed',
-            'co_argcount',
-            'co_cellvars',
-            'co_code',
-            'co_consts',
-            'co_filename',
-            'co_firstlineno',
-            'co_flags',
-            'co_freevars',
-            'co_lnotab',
-            'co_name',
-            'co_names',
-            'co_nlocals',
-            'co_stacksize',
-            'co_varnames',
-            'conjugate',
-            'copy',
-            'count',
-            'decode',
-            'encode',
-            'endswith',
-            'expandtabs',
-            'extend',
-            'fileno',
-            'find',
-            'flush',
-            'func_closure',
-            'func_code',
-            'func_defaults',
-            'func_dict',
-            'func_doc',
-            'func_globals',
-            'func_name',
-            'get',
-            'has_key',
-            'im_class',
-            'im_func',
-            'im_self',
-            'imag',
-            'index',
-            'insert',
-            'isalnum',
-            'isalpha',
-            'isatty',
-            'isdigit',
-            'islower',
-            'isspace',
-            'istitle',
-            'isupper',
-            'items',
-            'iteritems',
-            'iterkeys',
-            'itervalues',
-            'join',
-            'keys',
-            'ljust',
-            'lower',
-            'lstrip',
-            'mode',
-            'mro',
-            'name',
-            'pop',
-            'popitem',
-            'real',
-            'read',
-            'readinto',
-            'readline',
-            'readlines',
-            'remove',
-            'replace',
-            'reverse',
-            'rfind',
-            'rindex',
-            'rjust',
-            'rstrip',
-            'seek',
-            'setdefault',
-            'softspace',
-            'sort',
-            'split',
-            'splitlines',
-            'start',
-            'startswith',
-            'step',
-            'stop',
-            'strip',
-            'swapcase',
-            'tell',
-            'title',
-            'tolist',
-            'translate',
-            'truncate',
-            'update',
-            'upper',
-            'values',
-            'write',
-            'writelines',
-            'xreadlines',
-        )
-
-# Since getAllAttributeNames() calls str(object),
-# we need to test for a broken __str__ method.
-class BrokenStr:
-    def __str__(self):
-        raise Exception
-    
-brokenStr = BrokenStr()
-
-class GetAttributeNamesTestCase(GetAttributeTestCase):
-
-    def setUp(self):
-        GetAttributeTestCase.setUp(self)
-        import PyCrust
-        spam = Spam()
-        self.f = open('test_introspect.py')
-        self.items = (
-            None,
-            int(123),
-            long(123),
-            float(123),
-            complex(123),
-            "",
-            unicode(""),
-            [],
-            (),
-            xrange(0),
-            {},
-            # Builtin function.
-            len,
-            # Builtin method.
-            [].append,
-            # User function.
-            ham,
-            # Byte-compiled code.
-            ham.func_code,
-            # Lambda.
-            lambda: None,
-            # Class with no init.
-            Bar,
-            # Instance with no init.
-            Bar(),
-            # Class with init and del.
-            Foo,
-            # Instance with init and del.
-            Foo(),
-            # Bound method.
-            spam.foo,
-            # Unbound method.
-            Spam.eggs,
-            # Callable instance.
-            spam,
-            # Module.
-            introspect,
-            # Package.
-            PyCrust,
-            # Buffer.
-            buffer(''),
-            # File.
-            self.f,
-            # Slice.
-            slice(0),
-            # Ellipsis.
-            Ellipsis,
-            # BrokenStr class.
-            BrokenStr,
-            # BrokenStr instance.
-            brokenStr,
-        )
-
-    def tearDown(self):
-        self.items = None
-        self.f.close()
-
-    def test_getAttributeNames(self):
-        for item in self.items:
-            self._checkAttributeNames(item)
-        if __builtins__.has_key('object'):
-            self._checkAttributeNames(object)
-
-    def test_getAttributeNames_NoSingle(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeSingle=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_' or attribute[:2] == '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAttributeNames_NoDouble(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[:2] != '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAttributeNames_NoSingleOrDouble(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeSingle=0, 
-                                                  includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def _checkAttributeNames(self, item):
-        result = introspect.getAttributeNames(item)
-        attributes = [attribute for attribute in self.values \
-                      if hasattr(item, attribute)]
-        for attribute in attributes:
-            self.assert_(attribute in result, 
-                         ':item: %r :attribute: %r' % (item, attribute))
-
-
-class GetAutoCompleteListTestCase(GetAttributeTestCase):
-
-    def setUp(self):
-        GetAttributeTestCase.setUp(self)
-        self.items = (
-            'None.',
-            '123 .',
-            '"".',
-            '[].',
-            '().',
-            '{}.',
-            # Builtin function.
-            'len.',
-            # Builtin method.
-            '[].append.',
-        )
-
-    def test_getAutoCompleteList(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item)
-            object = eval(item[:-1])
-            attributes = [attribute for attribute in self.values \
-                          if hasattr(object, attribute)]
-            for attribute in attributes:
-                self.assert_(attribute in result, 
-                             ':item: %r :attribute: %r' % (item, attribute))
-
-    def test_getAutoCompleteList_NoSingle(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeSingle=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_' or attribute[:2] == '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAutoCompleteList_NoDouble(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[:2] != '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAutoCompleteList_NoSingleOrDouble(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeSingle=0, 
-                                                    includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-
-# Support for GetConstructorTestCase.
-
-class A1:
-    def __init__(self, a):
-        self.a = a
-
-class B1(A1):
-    def __init__(self, b):
-        self.b = b
-
-class C1(A1):
-    pass
-
-class D1(C1, B1):
-    pass
-
-if __builtins__.has_key('object'):
-    class A2(object):
-        def __init__(self, a):
-            self.a = a
-
-    class B2(A2):
-        def __init__(self, b):
-            self.b = b
-
-    class C2(A2):
-        pass
-
-    class D2(C2, B2):
-        pass
-    
-class N:
-    pass
-
-class O:
-    def __init__(self, a, b=2, *args, **kwargs):
-        pass
-
-class P(O):
-    pass
-
-class Q(P):
-    def __init__(self, c, d=4):
-        pass
-
-class GetConstructorTestCase(unittest.TestCase):
-
-    def test_getConstructor(self):
-        args = ('self', 'a', 'b', 'args', 'kwargs')
-        varnames = introspect.getConstructor(O).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        varnames = introspect.getConstructor(P).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        args = ('self', 'c', 'd')
-        varnames = introspect.getConstructor(Q).func_code.co_varnames
-        self.assertEqual(varnames, args)
-
-    def test_getConstructor_None(self):
-        values = (N, 1, 'spam', {}, [], (), dir)
-        for value in values:
-            self.assertEqual(introspect.getConstructor(N), None)
-
-    def test_getConstructor_MultipleInheritance(self):
-        # Test old style inheritance rules.
-        args = ('self', 'a')
-        varnames = introspect.getConstructor(D1).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        if __builtins__.has_key('object'):
-            # Test new style inheritance rules as well.
-            args = ('self', 'b')
-            varnames = introspect.getConstructor(D2).func_code.co_varnames
-            self.assertEqual(varnames, args)
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/test_pseudo.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import pseudo
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = pseudo
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.PseudoFile)
-        self.assert_(module.PseudoFileErr)
-        self.assert_(module.PseudoFileIn)
-        self.assert_(module.PseudoFileOut)
-        self.assert_(module.PseudoKeyword)
-
-
-class PseudoTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-
-class PseudoFileTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-
-class PseudoFileOutTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-    def _write(self):
-        pass
-
-    def test_PseudoFileOut_goodInit(self):
-        self.assert_(pseudo.PseudoFileOut(write=self._write))
-
-    def test_PseudoFileOut_badInit(self):
-        self.assertRaises(ValueError, pseudo.PseudoFileOut, write='bad')
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/test_version.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-import types
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import version
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = version
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.VERSION)
-
-
-class VersionTestCase(unittest.TestCase):
-
-    def test_VERSION(self):
-        self.assert_(type(version.VERSION) is types.StringType)
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/testall.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-import unittest
-import glob
-import os
-
-
-def suite():
-    """Return a test suite containing all test cases in all test modules. 
-    Searches the current directory for any modules matching test_*.py."""
-    suite = unittest.TestSuite()
-    for filename in glob.glob('test_*.py'):
-        module = __import__(os.path.splitext(filename)[0])
-        suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(module))
-    return suite
-
-
-if __name__ == '__main__':
-    unittest.main(defaultTest='suite')
-

wxPython/wxPython/py/version.py

@@ -1,11 +0,0 @@
-"""Provides an object representing the current 'version' or 'release'
-of PyCrust as a whole.  Individual classes, such as the shell, filling
-and interpreter, each have a revision property based on the CVS
-Revision."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-VERSION = '0.9.1'
- 

wxPython/wxPython/py/wxd/Accelerators.py

@@ -1,58 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class AcceleratorEntry:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def GetCommand(self):
-        """"""
-        pass
-
-    def GetFlags(self):
-        """"""
-        pass
-
-    def GetKeyCode(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-
-class AcceleratorTable(Object):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/App.py

@@ -1,358 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class PyApp(EvtHandler):
-    """Python Application base class.
-
-    It is used to:
-
-    - set and get application-wide properties;
-
-    - implement the windowing system message or event loop;
-
-    - initiate application processing via App.OnInit;
-
-    - allow default processing of events not handled by other objects
-      in the application."""
-
-    def __init__(self):
-        """Create a PyApp instance."""
-        pass
-
-    def Dispatch(self):
-        """Dispatches the next event in the windowing system event
-        queue.
-
-        This can be used for programming event loops."""
-        pass
-
-    def ExitMainLoop(self):
-        """Call this to explicitly exit the main message (event) loop.
-
-        You should normally exit the main loop (and the application)
-        by deleting the top window, which wxPython does automatically."""
-        pass
-
-    def GetAppName(self):
-        """Return the application name."""
-        pass
-
-    def GetAssertMode(self):
-        """Return the current assertion mode."""
-        pass
-
-    def GetAuto3D(self):
-        """Returns True if 3D control mode is on, False otherwise.
-        Windows only."""
-        pass
-
-    def GetClassName(self):
-        """Return the class name of the application."""
-        pass
-
-    def GetExitOnFrameDelete(self):
-        """Returns True if the application will exit when the
-        top-level window is deleted, False otherwise."""
-        pass
-
-    def GetPrintMode(self):
-        """Deprecated."""
-        pass
-
-    def GetTopWindow(self):
-        """Return the top window.
-
-        If the top window hasn't been set using App.SetTopWindow,
-        this method will find the first top-level window (frame or
-        dialog) and return that."""
-        pass
-
-    def GetUseBestVisual(self):
-        """Return True if the application will use the best visual on
-        systems that support different visuals, False otherwise."""
-        pass
-
-    def GetVendorName(self):
-        """Return the application's vendor name."""
-        pass
-
-    def Initialized(self):
-        """Return True if the application has been initialized
-        (i.e. if App.OnInit has returned successfully). This can be
-        useful for error message routines to determine which method of
-        output is best for the current state of the program (some
-        windowing systems may not like dialogs to pop up before the
-        main loop has been entered)."""
-        pass
-
-    def MainLoop(self):
-        """Called by wxWindows on creation of the application.
-        Override this if you wish to provide your own
-        (environment-dependent) main loop.
-
-        Return 0 under X, and the wParam of the WM_QUIT message under
-        Windows."""
-        pass
-
-    def OnAssert(self, file, line, cond, msg):
-        """Called when an assert failure occurs, i.e. the condition
-        specified in ASSERT macro evaluated to FALSE. It is only
-        called in debug mode (when __WXDEBUG__ is defined) as asserts
-        are not left in the release code at all.
-
-        The base class version show the default assert failure dialog
-        box proposing to the user to stop the program, continue or
-        ignore all subsequent asserts.
-
-        file is the name of the source file where the assert occured
-
-        line is the line number in this file where the assert occured
-
-        cond is the condition of the failed assert in string form
-
-        msg is the message specified as argument to ASSERT_MSG or
-        FAIL_MSG, will be NULL if just ASSERT or FAIL was used"""
-        pass
-
-    def OnExit(self):
-        """Provide this member function for any processing which needs
-        to be done as the application is about to exit.  OnExit is
-        called after destroying all application windows and controls,
-        but before wxWindows cleanup."""
-        pass
-
-    def OnInit(self):
-        """This must be provided by the application, and will usually
-        create the application's main window, optionally calling
-        App.SetTopWindow.
-
-        Return True to continue processing, False to exit the
-        application."""
-        pass
-
-    def OnInitGui(self):
-        """Called just after the platform's GUI has been initialized,
-        but before the App.OnInit() gets called. Rarely needed in
-        practice. Unlike App.OnInit(), does not need to return
-        True/False."""
-        pass
-    
-    def Pending(self):
-        """Return True if unprocessed events are in the window system
-        event queue."""
-        pass
-
-    def ProcessIdle(self):
-        """Sends the EVT_IDLE event and is called inside the MainLoop.
-        
-        You only need this if you implement your own main loop."""
-        pass
-
-    def SetAppName(self, name):
-        """Set the name of the application."""
-        pass
-
-    def SetAssertMode(self, mode):
-        """Lets you control how C++ assertions are processed.
-
-        Valid modes are: PYAPP_ASSERT_SUPPRESS,
-        PYAPP_ASSERT_EXCEPTION, and PYAPP_ASSERT_DIALOG.  Using
-        _SUPPRESS will give you behavior like the old final builds and
-        the assert will be ignored, _EXCEPTION is the new default
-        described above, and _DIALOG is like the default in 2.3.3.1
-        and prior hybrid builds.  You can also combine _EXCEPTION and
-        _DIALOG if you wish, although I don't know why you would."""
-        pass
-
-    def SetAuto3D(self, auto3D):
-        """Switches automatic 3D controls on or off.  Windows only.
-
-        If auto3D is True, all controls will be created with 3D
-        appearances unless overridden for a control or dialog.  The
-        default is True."""
-        pass
-
-    def SetClassName(self, name):
-        """Set the class name of the application."""
-        pass
-
-    def SetExitOnFrameDelete(self, flag):
-        """If flag is True (the default), the application will exit
-        when the top-level frame is deleted.  If False, the
-        application will continue to run."""
-        pass
-
-    def SetPrintMode(self, mode):
-        """Deprecated."""
-        pass
-
-    def SetTopWindow(self, window):
-        """Set the 'top' window.
-
-        You can call this from within App.OnInit to let wxWindows
-        know which is the main window.  You don't have to set the top
-        window; it is only a convenience so that (for example) certain
-        dialogs without parents can use a specific window as the top
-        window.  If no top window is specified by the application,
-        wxWindows just uses the first frame or dialog in its top-level
-        window list, when it needs to use the top window."""
-        pass
-
-    def SetUseBestVisual(self, flag):
-        """Allows the programmer to specify whether the application
-        will use the best visual on systems that support several
-        visual on the same display.  This is typically the case under
-        Solaris and IRIX, where the default visual is only 8-bit
-        whereas certain applications are supposed to run in TrueColour
-        mode.
-
-        Note that this function has to be called in the constructor of
-        the App instance and won't have any effect when called later
-        on.
-
-        This function currently only has effect under GTK."""
-        pass
-
-    def SetVendorName(self, name):
-        """Sets the name of application's vendor.  The name will be
-        used in registry access."""
-        pass
-
-    def Yield(self, onlyIfNeeded=False):
-        """Yields control to pending messages in the windowing system.
-        This can be useful, for example, when a time-consuming process
-        writes to a text window.  Without an occasional yield, the
-        text window will not be updated properly, and on systems with
-        cooperative multitasking, such as Windows 3.1 other processes
-        will not respond.
-
-        Caution should be exercised, however, since yielding may allow
-        the user to perform actions which are not compatible with the
-        current task.  Disabling menu items or whole menus during
-        processing can avoid unwanted reentrance of code: see
-        wx.SafeYield for a better function.
-
-        Calling Yield() recursively is normally an error and an assert
-        failure is raised in debug build if such situation is
-        detected.  However if the the onlyIfNeeded parameter is True,
-        the method will just silently return False instead."""
-        pass
-
-
-from wxPython.wx import wxPlatform
-_redirect = (wxPlatform == '__WXMSW__' or wxPlatform == '__WXMAC__')
-del wxPlatform
-
-
-class App(PyApp):
-    """The main application class.
-
-    Inherit from this class and implement an OnInit method that
-    creates a frame and then calls self.SetTopWindow(frame)."""
-
-    def __init__(self, redirect=_redirect, filename=None, useBestVisual=False):
-        """Create an App instance.
-
-        redirect defaults to True on Windows and Mac. If redirect is
-        True, stdio goes to an output window or a file if filename is
-        not None."""
-        pass
-
-
-del _redirect
-
-
-class PyOnDemandOutputWindow:
-    """Used by App to display stdout and stderr messages if app is
-    created using App(redirect=True).  Mostly useful on Windows or
-    Mac where apps aren't always launched from the command line."""
-    pass
-
-
-class PySimpleApp(App):
-    """Use instead of App for simple apps with a simple frame or
-    dialog, particularly for testing."""
-
-    def __init__(self, flag=0):
-        """Create a PySimpleApp instance.
-
-        flag is the same as App's redirect parameter to redirect stdio."""
-        pass
-
-    def OnInit(self):
-        """Automatically does a wx.InitAllImageHandlers()."""
-        pass
-
-
-class PyWidgetTester(App):
-    """Use instead of App for testing widgets. Provides a frame
-    containing an instance of a widget.
-
-    Create a PyWidgetTester instance with the desired size for the
-    frame, then create the widget and show the frame using SetWidget."""
-
-    def __init__(self, size=(250, 100)):
-        """Create a PyWidgetTester instance, with no stdio redirection.
-
-        size is for the frame to hold the widget."""
-        pass
-
-    def OnInit(self):
-        """Creates a frame that will hold the widget to be tested."""
-        pass
-
-    def SetWidget(self, widgetClass, *args):
-        """Create a widgetClass instance using the supplied args and
-        with a frame as parent, then show the frame."""
-        pass
-
-
-class SingleInstanceChecker:
-    """Allows one to check that only a single instance of a program is
-    running. To do it, you should create an object of this class. As
-    long as this object is alive, calls to IsAnotherRunning() from
-    other processes will return True.
-
-    As the object should have the life span as big as possible, it
-    makes sense to create it either as a global or in App.OnInit()."""
-
-    def __init__(self, name, path=wx.EmptyString):
-        """Create a SingleInstanceChecker instance.
-
-        name should be as unique as possible. It is used as the mutex
-        name under Win32 and the lock file name under Unix.
-        App.GetAppName() and wx.GetUserId() are commonly used.
-
-        path is optional and is ignored under Win32 and used as the
-        directory to create the lock file in under Unix (default is
-        wx.GetHomeDir())."""
-        pass
-
-    def Create(self, name, path=wx.EmptyString):
-        """Create a SingleInstanceChecker instance."""
-        pass
-
-    def IsAnotherRunning(self):
-        """Return True if another copy of this program is already running."""
-        pass

wxPython/wxPython/py/wxd/Base.py

@@ -1,206 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class Object:
-    """Base class for all other wxPython classes."""
-    
-    def __init__(self):
-        """Create a Object instance."""
-        pass
-
-    def Destroy(self):
-        """Destroy the Object instance."""
-        pass
-
-    def GetClassName(self):
-        """Return the name of the class."""
-        pass
-
-
-class EvtHandler(Object):
-    """Base class that can handle events from the windowing system.
-
-    If the handler is part of a chain, the destructor will unlink
-    itself and restore the previous and next handlers so that they
-    point to each other."""
-
-    def __init__(self):
-        """Create a EvtHandler instance."""
-        pass
-
-    def AddPendingEvent(self, event):
-        """Post an event to be processed later.
-
-        event is an Event instance to add to process queue.
-
-        The difference between sending an event (using the
-        ProcessEvent method) and posting it is that in the first case
-        the event is processed before the function returns, while in
-        the second case, the function returns immediately and the
-        event will be processed sometime later (usually during the
-        next event loop iteration).
-
-        A copy of event is made by the function, so the original can
-        be deleted as soon as function returns (it is common that the
-        original is created on the stack).  This requires that the
-        Event::Clone method be implemented by event so that it can
-        be duplicated and stored until it gets processed.
-
-        This is also the method to call for inter-thread
-        communication.  It will post events safely between different
-        threads which means that this method is thread-safe by using
-        critical sections where needed.  In a multi-threaded program,
-        you often need to inform the main GUI thread about the status
-        of other working threads and such notification should be done
-        using this method.
-
-        This method automatically wakes up idle handling if the
-        underlying window system is currently idle and thus would not
-        send any idle events.  (Waking up idle handling is done
-        calling WakeUpIdle.)"""
-        pass
-
-    def Connect(self, id, lastId, eventType, func):
-        """Connects the given function dynamically with the event
-        handler, id and event type.  This is an alternative to the use
-        of static event tables.
-
-        id is the identifier (or first of the identifier range) to be
-        associated with the event handler function.
-
-        lastId is the second part of the identifier range to be
-        associated with the event handler function.
-
-        eventType is the event type to be associated with this event
-        handler.
-
-        function is the event handler function.
-
-        userData is data to be associated with the event table entry."""
-        pass
-
-    def Disconnect(self, id, lastId=-1, eventType=wx.EVT_NULL):
-        """Disconnects the given function dynamically from the event
-        handler, using the specified parameters as search criteria and
-        returning True if a matching function has been found and
-        removed.  This method can only disconnect functions which have
-        been added using the EvtHandler.Connect method. There is no
-        way to disconnect functions connected using the (static) event
-        tables.
-
-        id is the identifier (or first of the identifier range) to be
-        associated with the event handler function.
-
-        lastId is the second part of the identifier range to be
-        associated with the event handler function.
-
-        eventType is the event type to be associated with this event
-        handler.
-
-        function is the event handler function.
-
-        userData is data to be associated with the event table entry."""
-        pass
-
-    def GetEvtHandlerEnabled(self):
-        """Return True if the event handler is enabled, False
-        otherwise."""
-        pass
-
-    def GetNextHandler(self):
-        """Return the next handler in the chain."""
-        pass
-
-    def GetPreviousHandler(self):
-        """Return the previous handler in the chain."""
-        pass
-
-    def ProcessEvent(self, event):
-        """Processes an event, searching event tables and calling zero
-        or more suitable event handler function(s).  Return True if a
-        suitable event handler function was found and executed, and
-        the function did not call Event.Skip().
-
-        event is an Event to process.
-
-        Normally, your application would not call this function: it is
-        called in the wxPython implementation to dispatch incoming
-        user interface events to the framework (and application).
-
-        However, you might need to call it if implementing new
-        functionality (such as a new control) where you define new
-        event types, as opposed to allowing the user to override
-        virtual functions.
-
-        An instance where you might actually override the ProcessEvent
-        function is where you want to direct event processing to event
-        handlers not normally noticed by wxWindows.  For example, in
-        the document/view architecture, documents and views are
-        potential event handlers.  When an event reaches a frame,
-        ProcessEvent will need to be called on the associated document
-        and view in case event handler functions are associated with
-        these objects.  The property classes library (Property) also
-        overrides ProcessEvent for similar reasons.
-
-        The normal order of event table searching is as follows:
-
-        1. If the object is disabled (via a call to
-        EvtHandler.SetEvtHandlerEnabled) the function skips to step
-        (6).
-
-        2. If the object is a Window, ProcessEvent is recursively
-        called on the window's Validator.  If this returns TRUE, the
-        function exits.
-
-        3. SearchEventTable is called for this event handler.  If this
-        fails, the base class table is tried, and so on until no more
-        tables exist or an appropriate function was found, in which
-        case the function exits.
-
-        4. The search is applied down the entire chain of event
-        handlers (usually the chain has a length of one).  If this
-        succeeds, the function exits.
-
-        5. If the object is a Window and the event is a
-        CommandEvent, ProcessEvent is recursively applied to the
-        parent window's event handler.  If this returns TRUE, the
-        function exits.
-
-        6. Finally, ProcessEvent is called on the App object.
-
-        See also:
-
-        EvtHandler::SearchEventTable"""
-        pass
-
-    def SetEvtHandlerEnabled(self, enabled):
-        """Enable or disable the event handler.
-
-        You can use this function to avoid having to remove the event
-        handler from the chain, for example when implementing a dialog
-        editor and changing from edit to test mode."""
-        pass
-
-    def SetNextHandler(self, handler):
-        """Set the pointer to the next handler."""
-        pass
-
-    def SetPreviousHandler(self, handler):
-        """Set the pointer to the previous handler."""
-        pass
-
-

wxPython/wxPython/py/wxd/ClipDragDrop.py

@@ -1,485 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class Clipboard(Object):
-    """"""
-
-    def AddData(self):
-        """"""
-        pass
-
-    def Clear(self):
-        """"""
-        pass
-
-    def Close(self):
-        """"""
-        pass
-
-    def Flush(self):
-        """"""
-        pass
-
-    def GetData(self):
-        """"""
-        pass
-
-    def IsOpened(self):
-        """"""
-        pass
-
-    def IsSupported(self):
-        """"""
-        pass
-
-    def Open(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def UsePrimarySelection(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataFormat:
-    """"""
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetType(self):
-        """"""
-        pass
-
-    def SetId(self):
-        """"""
-        pass
-
-    def SetType(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataObject:
-    """"""
-
-    def GetAllFormats(self):
-        """"""
-        pass
-
-    def GetDataHere(self):
-        """"""
-        pass
-
-    def GetDataSize(self):
-        """"""
-        pass
-
-    def GetFormatCount(self):
-        """"""
-        pass
-
-    def GetPreferredFormat(self):
-        """"""
-        pass
-
-    def IsSupportedFormat(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataObjectComposite(DataObject):
-    """"""
-
-    def Add(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataObjectSimple(DataObject):
-    """"""
-
-    def GetFormat(self):
-        """"""
-        pass
-
-    def SetFormat(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyDataObjectSimple(DataObjectSimple):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class BitmapDataObject(DataObjectSimple):
-    """"""
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def SetBitmap(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyBitmapDataObject(BitmapDataObject):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class CustomDataObject(DataObjectSimple):
-    """"""
-
-    def GetData(self):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def TakeData(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DragImage(Object):
-    """"""
-
-    def BeginDrag(self):
-        """"""
-        pass
-
-    def BeginDrag2(self):
-        """"""
-        pass
-
-    def EndDrag(self):
-        """"""
-        pass
-
-    def GetImageRect(self):
-        """"""
-        pass
-
-    def Hide(self):
-        """"""
-        pass
-
-    def Move(self):
-        """"""
-        pass
-
-    def RedrawImage(self):
-        """"""
-        pass
-
-    def SetBackingBitmap(self):
-        """"""
-        pass
-
-    def Show(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DropSource:
-    """"""
-
-    def DoDragDrop(self):
-        """"""
-        pass
-
-    def GetDataObject(self):
-        """"""
-        pass
-
-    def SetCursor(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_GiveFeedback(self):
-        """"""
-        pass
-
-
-class DropTarget:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyDropTarget(DropTarget):
-    """"""
-
-    def GetData(self):
-        """"""
-        pass
-
-    def GetDataObject(self):
-        """"""
-        pass
-
-    def SetDataObject(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnDragOver(self):
-        """"""
-        pass
-
-    def base_OnDrop(self):
-        """"""
-        pass
-
-    def base_OnEnter(self):
-        """"""
-        pass
-
-    def base_OnLeave(self):
-        """"""
-        pass
-
-
-class FileDataObject(DataObjectSimple):
-    """"""
-
-    def GetFilenames(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileDropTarget(PyDropTarget):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnData(self):
-        """"""
-        pass
-
-    def base_OnDragOver(self):
-        """"""
-        pass
-
-    def base_OnDrop(self):
-        """"""
-        pass
-
-    def base_OnEnter(self):
-        """"""
-        pass
-
-    def base_OnLeave(self):
-        """"""
-        pass
-
-
-class TextDataObject(DataObjectSimple):
-    """"""
-
-    def GetText(self):
-        """"""
-        pass
-
-    def GetTextLength(self):
-        """"""
-        pass
-
-    def SetText(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyTextDataObject(TextDataObject):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TextDropTarget(PyDropTarget):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnData(self):
-        """"""
-        pass
-
-    def base_OnDragOver(self):
-        """"""
-        pass
-
-    def base_OnDrop(self):
-        """"""
-        pass
-
-    def base_OnEnter(self):
-        """"""
-        pass
-
-    def base_OnLeave(self):
-        """"""
-        pass
-
-
-class URLDataObject(DataObjectComposite):
-    """"""
-
-    def GetURL(self):
-        """"""
-        pass
-
-    def SetURL(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Config.py

@@ -1,199 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class ConfigBase:
-    """"""
-
-    def DeleteAll(self):
-        """"""
-        pass
-
-    def DeleteEntry(self):
-        """"""
-        pass
-
-    def DeleteGroup(self):
-        """"""
-        pass
-
-    def Exists(self):
-        """"""
-        pass
-
-    def ExpandEnvVars(self):
-        """"""
-        pass
-
-    def Flush(self):
-        """"""
-        pass
-
-    def GetAppName(self):
-        """"""
-        pass
-
-    def GetEntryType(self):
-        """"""
-        pass
-
-    def GetFirstEntry(self):
-        """"""
-        pass
-
-    def GetFirstGroup(self):
-        """"""
-        pass
-
-    def GetNextEntry(self):
-        """"""
-        pass
-
-    def GetNextGroup(self):
-        """"""
-        pass
-
-    def GetNumberOfEntries(self):
-        """"""
-        pass
-
-    def GetNumberOfGroups(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetVendorName(self):
-        """"""
-        pass
-
-    def HasEntry(self):
-        """"""
-        pass
-
-    def HasGroup(self):
-        """"""
-        pass
-
-    def IsExpandingEnvVars(self):
-        """"""
-        pass
-
-    def IsRecordingDefaults(self):
-        """"""
-        pass
-
-    def Read(self):
-        """"""
-        pass
-
-    def ReadBool(self):
-        """"""
-        pass
-
-    def ReadFloat(self):
-        """"""
-        pass
-
-    def ReadInt(self):
-        """"""
-        pass
-
-    def RenameEntry(self):
-        """"""
-        pass
-
-    def RenameGroup(self):
-        """"""
-        pass
-
-    def SetAppName(self):
-        """"""
-        pass
-
-    def SetExpandEnvVars(self):
-        """"""
-        pass
-
-    def SetPath(self):
-        """"""
-        pass
-
-    def SetRecordDefaults(self):
-        """"""
-        pass
-
-    def SetStyle(self):
-        """"""
-        pass
-
-    def SetVendorName(self):
-        """"""
-        pass
-
-    def Write(self):
-        """"""
-        pass
-
-    def WriteBool(self):
-        """"""
-        pass
-
-    def WriteFloat(self):
-        """"""
-        pass
-
-    def WriteInt(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Config(ConfigBase):
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileConfig(ConfigBase):
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/DataStructures.py

@@ -1,485 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class Point:
-    """"""
-
-    def Set(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class Point2DDouble:
-    """"""
-
-    def GetCrossProduct(self):
-        """"""
-        pass
-
-    def GetDistance(self):
-        """"""
-        pass
-
-    def GetDistanceSquare(self):
-        """"""
-        pass
-
-    def GetDotProduct(self):
-        """"""
-        pass
-
-    def GetFloor(self):
-        """"""
-        pass
-
-    def GetRounded(self):
-        """"""
-        pass
-
-    def GetVectorAngle(self):
-        """"""
-        pass
-
-    def GetVectorLength(self):
-        """"""
-        pass
-
-    def Normalize(self):
-        """"""
-        pass
-
-    def SetPolarCoordinates(self):
-        """"""
-        pass
-
-    def SetVectorAngle(self):
-        """"""
-        pass
-
-    def SetVectorLength(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __iadd__(self):
-        """"""
-        pass
-
-    def __idiv__(self):
-        """"""
-        pass
-
-    def __imul__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __isub__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __neg__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class RealPoint:
-    """"""
-
-    def Set(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class Rect:
-    """"""
-
-    def GetBottom(self):
-        """"""
-        pass
-
-    def GetHeight(self):
-        """"""
-        pass
-
-    def GetLeft(self):
-        """"""
-        pass
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetRight(self):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def GetTop(self):
-        """"""
-        pass
-
-    def GetWidth(self):
-        """"""
-        pass
-
-    def GetX(self):
-        """"""
-        pass
-
-    def GetY(self):
-        """"""
-        pass
-
-    def Inflate(self):
-        """"""
-        pass
-
-    def Inside(self):
-        """"""
-        pass
-
-    def SetBottom(self):
-        """"""
-        pass
-
-    def SetHeight(self):
-        """"""
-        pass
-
-    def SetLeft(self):
-        """"""
-        pass
-
-    def SetPosition(self):
-        """"""
-        pass
-
-    def SetRight(self):
-        """"""
-        pass
-
-    def SetSize(self):
-        """"""
-        pass
-
-    def SetTop(self):
-        """"""
-        pass
-
-    def SetWidth(self):
-        """"""
-        pass
-
-    def SetX(self):
-        """"""
-        pass
-
-    def SetY(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class Size:
-    """"""
-
-    def GetHeight(self):
-        """"""
-        pass
-
-    def GetWidth(self):
-        """"""
-        pass
-
-    def GetX(self):
-        """"""
-        pass
-
-    def GetY(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def SetHeight(self):
-        """"""
-        pass
-
-    def SetWidth(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/DateTime.py

@@ -1,553 +0,0 @@
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class DateSpan:
-    """"""
-
-    def Add(self):
-        """"""
-        pass
-
-    def GetDays(self):
-        """"""
-        pass
-
-    def GetMonths(self):
-        """"""
-        pass
-
-    def GetTotalDays(self):
-        """"""
-        pass
-
-    def GetWeeks(self):
-        """"""
-        pass
-
-    def GetYears(self):
-        """"""
-        pass
-
-    def Multiply(self):
-        """"""
-        pass
-
-    def Neg(self):
-        """"""
-        pass
-
-    def SetDays(self):
-        """"""
-        pass
-
-    def SetMonths(self):
-        """"""
-        pass
-
-    def SetWeeks(self):
-        """"""
-        pass
-
-    def SetYears(self):
-        """"""
-        pass
-
-    def Subtract(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __mul__(self):
-        """"""
-        pass
-
-    def __neg__(self):
-        """"""
-        pass
-
-    def __rmul__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-
-class DateTime:
-    """"""
-
-    def AddDS(self):
-        """"""
-        pass
-
-    def AddTS(self):
-        """"""
-        pass
-
-    def Format(self):
-        """"""
-        pass
-
-    def FormatDate(self):
-        """"""
-        pass
-
-    def FormatISODate(self):
-        """"""
-        pass
-
-    def FormatISOTime(self):
-        """"""
-        pass
-
-    def FormatTime(self):
-        """"""
-        pass
-
-    def GetDay(self):
-        """"""
-        pass
-
-    def GetDayOfYear(self):
-        """"""
-        pass
-
-    def GetHour(self):
-        """"""
-        pass
-
-    def GetJDN(self):
-        """"""
-        pass
-
-    def GetJulianDayNumber(self):
-        """"""
-        pass
-
-    def GetLastMonthDay(self):
-        """"""
-        pass
-
-    def GetLastWeekDay(self):
-        """"""
-        pass
-
-    def GetMJD(self):
-        """"""
-        pass
-
-    def GetMillisecond(self):
-        """"""
-        pass
-
-    def GetMinute(self):
-        """"""
-        pass
-
-    def GetModifiedJulianDayNumber(self):
-        """"""
-        pass
-
-    def GetMonth(self):
-        """"""
-        pass
-
-    def GetNextWeekDay(self):
-        """"""
-        pass
-
-    def GetPrevWeekDay(self):
-        """"""
-        pass
-
-    def GetRataDie(self):
-        """"""
-        pass
-
-    def GetSecond(self):
-        """"""
-        pass
-
-    def GetTicks(self):
-        """"""
-        pass
-
-    def GetWeek(self):
-        """"""
-        pass
-
-    def GetWeekDay(self):
-        """"""
-        pass
-
-    def GetWeekDayInSameWeek(self):
-        """"""
-        pass
-
-    def GetWeekOfMonth(self):
-        """"""
-        pass
-
-    def GetWeekOfYear(self):
-        """"""
-        pass
-
-    def GetYear(self):
-        """"""
-        pass
-
-    def GetYearDay(self):
-        """"""
-        pass
-
-    def IsBetween(self):
-        """"""
-        pass
-
-    def IsDST(self):
-        """"""
-        pass
-
-    def IsEarlierThan(self):
-        """"""
-        pass
-
-    def IsEqualTo(self):
-        """"""
-        pass
-
-    def IsEqualUpTo(self):
-        """"""
-        pass
-
-    def IsLaterThan(self):
-        """"""
-        pass
-
-    def IsSameDate(self):
-        """"""
-        pass
-
-    def IsSameTime(self):
-        """"""
-        pass
-
-    def IsStrictlyBetween(self):
-        """"""
-        pass
-
-    def IsValid(self):
-        """"""
-        pass
-
-    def IsWorkDay(self):
-        """"""
-        pass
-
-    def MakeGMT(self):
-        """"""
-        pass
-
-    def MakeTimezone(self):
-        """"""
-        pass
-
-    def ParseDate(self):
-        """"""
-        pass
-
-    def ParseDateTime(self):
-        """"""
-        pass
-
-    def ParseFormat(self):
-        """"""
-        pass
-
-    def ParseRfc822Date(self):
-        """"""
-        pass
-
-    def ParseTime(self):
-        """"""
-        pass
-
-    def ResetTime(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def SetDay(self):
-        """"""
-        pass
-
-    def SetHMS(self):
-        """"""
-        pass
-
-    def SetHour(self):
-        """"""
-        pass
-
-    def SetJDN(self):
-        """"""
-        pass
-
-    def SetMillisecond(self):
-        """"""
-        pass
-
-    def SetMinute(self):
-        """"""
-        pass
-
-    def SetMonth(self):
-        """"""
-        pass
-
-    def SetSecond(self):
-        """"""
-        pass
-
-    def SetTimeT(self):
-        """"""
-        pass
-
-    def SetToCurrent(self):
-        """"""
-        pass
-
-    def SetToLastMonthDay(self):
-        """"""
-        pass
-
-    def SetToLastWeekDay(self):
-        """"""
-        pass
-
-    def SetToNextWeekDay(self):
-        """"""
-        pass
-
-    def SetToPrevWeekDay(self):
-        """"""
-        pass
-
-    def SetToTheWeek(self):
-        """"""
-        pass
-
-    def SetToWeekDay(self):
-        """"""
-        pass
-
-    def SetToWeekDayInSameWeek(self):
-        """"""
-        pass
-
-    def SetToYearDay(self):
-        """"""
-        pass
-
-    def SetYear(self):
-        """"""
-        pass
-
-    def Subtract(self):
-        """"""
-        pass
-
-    def SubtractDS(self):
-        """"""
-        pass
-
-    def SubtractTS(self):
-        """"""
-        pass
-
-    def ToGMT(self):
-        """"""
-        pass
-
-    def ToTimezone(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __cmp__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__add__DS(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__add__TS(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__sub__DS(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__sub__DT(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__sub__TS(self):
-        """"""
-        pass
-
-
-class TimeSpan:
-    """"""
-
-    def Abs(self):
-        """"""
-        pass
-
-    def Add(self):
-        """"""
-        pass
-
-    def Format(self):
-        """"""
-        pass
-
-    def GetDays(self):
-        """"""
-        pass
-
-    def GetHours(self):
-        """"""
-        pass
-
-    def GetMilliseconds(self):
-        """"""
-        pass
-
-    def GetMinutes(self):
-        """"""
-        pass
-
-    def GetSeconds(self):
-        """"""
-        pass
-
-    def GetWeeks(self):
-        """"""
-        pass
-
-    def IsEqualTo(self):
-        """"""
-        pass
-
-    def IsLongerThan(self):
-        """"""
-        pass
-
-    def IsNegative(self):
-        """"""
-        pass
-
-    def IsNull(self):
-        """"""
-        pass
-
-    def IsPositive(self):
-        """"""
-        pass
-
-    def IsShorterThan(self):
-        """"""
-        pass
-
-    def Multiply(self):
-        """"""
-        pass
-
-    def Neg(self):
-        """"""
-        pass
-
-    def Subtract(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __cmp__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __mul__(self):
-        """"""
-        pass
-
-    def __neg__(self):
-        """"""
-        pass
-
-    def __rmul__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Dialogs.py

@@ -1,471 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Frames import Frame
-import Parameters as wx
-from Window import TopLevelWindow
-
-
-class Dialog(TopLevelWindow):
-    """"""
-
-    def Centre(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def CreateButtonSizer(self):
-        """"""
-        pass
-
-    def CreateTextSizer(self):
-        """"""
-        pass
-
-    def EndModal(self):
-        """"""
-        pass
-
-    def GetReturnCode(self):
-        """"""
-        pass
-
-    def IsModal(self):
-        """"""
-        pass
-
-    def SetModal(self):
-        """"""
-        pass
-
-    def SetReturnCode(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ColourDialog(Dialog):
-    """"""
-
-    def GetColourData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ColourData(Object):
-    """"""
-
-    def GetChooseFull(self):
-        """"""
-        pass
-
-    def GetColour(self):
-        """"""
-        pass
-
-    def GetCustomColour(self):
-        """"""
-        pass
-
-    def SetChooseFull(self):
-        """"""
-        pass
-
-    def SetColour(self):
-        """"""
-        pass
-
-    def SetCustomColour(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ColourDatabase(Object):
-    """"""
-
-    def Append(self):
-        """"""
-        pass
-
-    def FindColour(self):
-        """"""
-        pass
-
-    def FindName(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DirDialog(Dialog):
-    """"""
-
-    def GetMessage(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def SetMessage(self):
-        """"""
-        pass
-
-    def SetPath(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileDialog(Dialog):
-    """"""
-
-    def GetDirectory(self):
-        """"""
-        pass
-
-    def GetFilename(self):
-        """"""
-        pass
-
-    def GetFilenames(self):
-        """"""
-        pass
-
-    def GetFilterIndex(self):
-        """"""
-        pass
-
-    def GetMessage(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def GetPaths(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetWildcard(self):
-        """"""
-        pass
-
-    def SetDirectory(self):
-        """"""
-        pass
-
-    def SetFilename(self):
-        """"""
-        pass
-
-    def SetFilterIndex(self):
-        """"""
-        pass
-
-    def SetMessage(self):
-        """"""
-        pass
-
-    def SetPath(self):
-        """"""
-        pass
-
-    def SetStyle(self):
-        """"""
-        pass
-
-    def SetWildcard(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FindReplaceDialog(Dialog):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetData(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FindReplaceData(Object):
-    """"""
-
-    def GetFindString(self):
-        """"""
-        pass
-
-    def GetFlags(self):
-        """"""
-        pass
-
-    def GetReplaceString(self):
-        """"""
-        pass
-
-    def SetFindString(self):
-        """"""
-        pass
-
-    def SetFlags(self):
-        """"""
-        pass
-
-    def SetReplaceString(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FontDialog(Dialog):
-    """"""
-
-    def GetFontData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FontData(Object):
-    """"""
-
-    def EnableEffects(self):
-        """"""
-        pass
-
-    def GetAllowSymbols(self):
-        """"""
-        pass
-
-    def GetChosenFont(self):
-        """"""
-        pass
-
-    def GetColour(self):
-        """"""
-        pass
-
-    def GetEnableEffects(self):
-        """"""
-        pass
-
-    def GetInitialFont(self):
-        """"""
-        pass
-
-    def GetShowHelp(self):
-        """"""
-        pass
-
-    def SetAllowSymbols(self):
-        """"""
-        pass
-
-    def SetChosenFont(self):
-        """"""
-        pass
-
-    def SetColour(self):
-        """"""
-        pass
-
-    def SetInitialFont(self):
-        """"""
-        pass
-
-    def SetRange(self):
-        """"""
-        pass
-
-    def SetShowHelp(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MessageDialog(Dialog):
-    """"""
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-
-class MultiChoiceDialog(Dialog):
-    """"""
-
-    def GetSelections(self):
-        """"""
-        pass
-
-    def SetSelections(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ProgressDialog(Frame):
-    """"""
-
-    def Resume(self):
-        """"""
-        pass
-
-    def Update(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SingleChoiceDialog(Dialog):
-    """"""
-
-    def GetSelection(self):
-        """"""
-        pass
-
-    def GetStringSelection(self):
-        """"""
-        pass
-
-    def SetSelection(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class TextEntryDialog(Dialog):
-    """"""
-
-    def GetValue(self):
-        """"""
-        pass
-
-    def SetValue(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/Errors.py

@@ -1,25 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class PyAssertionError(AssertionError):
-    """"""
-    pass
-
-
-class PyDeadObjectError(AttributeError):
-    """Instances of wx objects that are OOR capable will have their
-    __class__ attribute changed to a _wxPyDeadObject class when the
-    C++ object is deleted.  Subsequent attempts to access object
-    attributes will raise this error, rather than segfault."""
-    pass

wxPython/wxPython/py/wxd/EventFunctions.py

@@ -1,794 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-def EVT_ACTIVATE(win, func):
-    """"""
-    pass
-
-def EVT_ACTIVATE_APP(win, func):
-    """"""
-    pass
-
-def EVT_BUTTON(win, id, func):
-    """"""
-    pass
-
-def EVT_CALCULATE_LAYOUT():
-    """"""
-    pass
-
-def EVT_CHAR(win, func):
-    """"""
-    pass
-
-def EVT_CHAR_HOOK(win, func):
-    """"""
-    pass
-
-def EVT_CHECKBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_CHECKLISTBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_CHILD_FOCUS(win, func):
-    """"""
-    pass
-
-def EVT_CHOICE(win, id, func):
-    """"""
-    pass
-
-def EVT_CLOSE(win, func):
-    """"""
-    pass
-
-def EVT_COMBOBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND(win, id, cmd, func):
-    """"""
-    pass
-
-def EVT_COMMAND_ENTER(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_FIND():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_CLOSE():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_NEXT():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_REPLACE():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_REPLACE_ALL():
-    """"""
-    pass
-
-def EVT_COMMAND_KILL_FOCUS(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_LEFT_CLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_LEFT_DCLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_RANGE(win, id1, id2, cmd, func):
-    """"""
-    pass
-
-def EVT_COMMAND_RIGHT_CLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_RIGHT_DCLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_BOTTOM(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_LINEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_LINEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_PAGEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_PAGEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_THUMBRELEASE(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_THUMBTRACK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_TOP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_BOTTOM(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_ENDSCROLL(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_LINEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_LINEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_PAGEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_PAGEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_THUMBRELEASE(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_THUMBTRACK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_TOP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SET_FOCUS(win, id, func):
-    """"""
-    pass
-
-def EVT_CONTEXT_MENU(win, func):
-    """"""
-    pass
-
-def EVT_DISPLAY_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_DROP_FILES(win, func):
-    """"""
-    pass
-
-def EVT_END_PROCESS(eh, id, func):
-    """"""
-    pass
-
-def EVT_END_SESSION(win, func):
-    """"""
-    pass
-
-def EVT_ENTER_WINDOW(win, func):
-    """"""
-    pass
-
-def EVT_ERASE_BACKGROUND(win, func):
-    """"""
-    pass
-
-def EVT_ICONIZE(win, func):
-    """"""
-    pass
-
-def EVT_IDLE(win, func):
-    """"""
-    pass
-
-def EVT_INIT_DIALOG(win, func):
-    """"""
-    pass
-
-def EVT_JOYSTICK_EVENTS(win, func):
-    """"""
-    pass
-
-def EVT_JOY_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_JOY_MOVE(win, func):
-    """"""
-    pass
-
-def EVT_JOY_UP(win, func):
-    """"""
-    pass
-
-def EVT_JOY_ZMOVE(win, func):
-    """"""
-    pass
-
-def EVT_KEY_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_KEY_UP(win, func):
-    """"""
-    pass
-
-def EVT_KILL_FOCUS(win, func):
-    """"""
-    pass
-
-def EVT_LEAVE_WINDOW(win, func):
-    """"""
-    pass
-
-def EVT_LEFT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_LEFT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_LEFT_UP(win, func):
-    """"""
-    pass
-
-def EVT_LISTBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_LISTBOX_DCLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_LIST_BEGIN_DRAG():
-    """"""
-    pass
-
-def EVT_LIST_BEGIN_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_LIST_BEGIN_RDRAG():
-    """"""
-    pass
-
-def EVT_LIST_CACHE_HINT():
-    """"""
-    pass
-
-def EVT_LIST_COL_BEGIN_DRAG():
-    """"""
-    pass
-
-def EVT_LIST_COL_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_COL_DRAGGING():
-    """"""
-    pass
-
-def EVT_LIST_COL_END_DRAG():
-    """"""
-    pass
-
-def EVT_LIST_COL_RIGHT_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_DELETE_ALL_ITEMS():
-    """"""
-    pass
-
-def EVT_LIST_DELETE_ITEM():
-    """"""
-    pass
-
-def EVT_LIST_END_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_LIST_GET_INFO():
-    """"""
-    pass
-
-def EVT_LIST_INSERT_ITEM():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_ACTIVATED():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_DESELECTED():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_FOCUSED():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_MIDDLE_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_RIGHT_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_SELECTED():
-    """"""
-    pass
-
-def EVT_LIST_KEY_DOWN():
-    """"""
-    pass
-
-def EVT_LIST_SET_INFO():
-    """"""
-    pass
-
-def EVT_MAXIMIZE(win, func):
-    """"""
-    pass
-
-def EVT_MENU(win, id, func):
-    """"""
-    pass
-
-def EVT_MENU_CLOSE(win, func):
-    """"""
-    pass
-
-def EVT_MENU_HIGHLIGHT(win, id, func):
-    """"""
-    pass
-
-def EVT_MENU_HIGHLIGHT_ALL(win, func):
-    """"""
-    pass
-
-def EVT_MENU_OPEN(win, func):
-    """"""
-    pass
-
-def EVT_MENU_RANGE(win, id1, id2, func):
-    """"""
-    pass
-
-def EVT_MIDDLE_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_MIDDLE_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_MIDDLE_UP(win, func):
-    """"""
-    pass
-
-def EVT_MOTION(win, func):
-    """"""
-    pass
-
-def EVT_MOUSEWHEEL(win, func):
-    """"""
-    pass
-
-def EVT_MOUSE_CAPTURE_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_MOUSE_EVENTS(win, func):
-    """"""
-    pass
-
-def EVT_MOVE(win, func):
-    """"""
-    pass
-
-def EVT_NAVIGATION_KEY(win, func):
-    """"""
-    pass
-
-def EVT_NOTEBOOK_PAGE_CHANGED(win, id, func):
-    """"""
-    pass
-
-def EVT_NOTEBOOK_PAGE_CHANGING(win, id, func):
-    """"""
-    pass
-
-def EVT_PAINT(win, func):
-    """"""
-    pass
-
-def EVT_PALETTE_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_QUERY_END_SESSION(win, func):
-    """"""
-    pass
-
-def EVT_QUERY_LAYOUT_INFO():
-    """"""
-    pass
-
-def EVT_QUERY_NEW_PALETTE(win, func):
-    """"""
-    pass
-
-def EVT_RADIOBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_RADIOBUTTON(win, id, func):
-    """"""
-    pass
-
-def EVT_RIGHT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_RIGHT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_RIGHT_UP(win, func):
-    """"""
-    pass
-
-def EVT_SASH_DRAGGED(win, id, func):
-    """"""
-    pass
-
-def EVT_SASH_DRAGGED_RANGE(win, id1, id2, func):
-    """"""
-    pass
-
-def EVT_SCROLL(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_BOTTOM(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_LINEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_LINEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_PAGEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_PAGEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_THUMBRELEASE(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_THUMBTRACK(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_TOP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_BOTTOM(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_ENDSCROLL(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_LINEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_LINEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_PAGEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_PAGEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_THUMBRELEASE(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_THUMBTRACK(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_TOP(win, func):
-    """"""
-    pass
-
-def EVT_SET_CURSOR(win, func):
-    """"""
-    pass
-
-def EVT_SET_FOCUS(win, func):
-    """"""
-    pass
-
-def EVT_SHOW(win, func):
-    """"""
-    pass
-
-def EVT_SIZE():
-    """"""
-    pass
-
-def EVT_SLIDER(win, id, func):
-    """"""
-    pass
-
-def EVT_SPIN(win, id, func):
-    """"""
-    pass
-
-def EVT_SPINCTRL(win, id, func):
-    """"""
-    pass
-
-def EVT_SPIN_DOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_SPIN_UP(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_DOUBLECLICKED(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_SASH_POS_CHANGED(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_SASH_POS_CHANGING(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_UNSPLIT(win, id, func):
-    """"""
-    pass
-
-def EVT_SYS_COLOUR_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_LEFT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_LEFT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_LEFT_UP(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_MOVE(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_RIGHT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_RIGHT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_RIGHT_UP(win, func):
-    """"""
-    pass
-
-def EVT_TEXT(win, id, func):
-    """"""
-    pass
-
-def EVT_TEXT_ENTER(win, id, func):
-    """"""
-    pass
-
-def EVT_TEXT_MAXLEN(win, id, func):
-    """"""
-    pass
-
-def EVT_TEXT_URL(win, id, func):
-    """"""
-    pass
-
-def EVT_TIMER(win, id, func):
-    """"""
-    pass
-
-def EVT_TOGGLEBUTTON(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL_ENTER(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL_RANGE(win, id, id2, func):
-    """"""
-    pass
-
-def EVT_TOOL_RCLICKED(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL_RCLICKED_RANGE(win, id, id2, func):
-    """"""
-    pass
-
-def EVT_TREE_BEGIN_DRAG():
-    """"""
-    pass
-
-def EVT_TREE_BEGIN_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_TREE_BEGIN_RDRAG():
-    """"""
-    pass
-
-def EVT_TREE_DELETE_ITEM():
-    """"""
-    pass
-
-def EVT_TREE_END_DRAG():
-    """"""
-    pass
-
-def EVT_TREE_END_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_TREE_GET_INFO():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_ACTIVATED():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_COLLAPSED():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_COLLAPSING():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_EXPANDED():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_EXPANDING():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_MIDDLE_CLICK():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_RIGHT_CLICK():
-    """"""
-    pass
-
-def EVT_TREE_KEY_DOWN():
-    """"""
-    pass
-
-def EVT_TREE_SEL_CHANGED():
-    """"""
-    pass
-
-def EVT_TREE_SEL_CHANGING():
-    """"""
-    pass
-
-def EVT_TREE_SET_INFO():
-    """"""
-    pass
-
-def EVT_UPDATE_UI(win, id, func):
-    """"""
-    pass
-
-def EVT_UPDATE_UI_RANGE(win, id, id2, func):
-    """"""
-    pass
-
-def EVT_VLBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_WINDOW_CREATE(win, func):
-    """"""
-    pass
-
-def EVT_WINDOW_DESTROY(win, func):
-    """"""
-    pass
-

wxPython/wxPython/py/wxd/FileSystem.py

@@ -1,193 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class FSFile(Object):
-    """"""
-
-    def GetAnchor(self):
-        """"""
-        pass
-
-    def GetLocation(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetModificationTime(self):
-        """"""
-        pass
-
-    def GetStream(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileSystem(Object):
-    """"""
-
-    def ChangePathTo(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class CPPFileSystemHandler(Object):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileSystemHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def GetAnchor(self):
-        """"""
-        pass
-
-    def GetLeftLocation(self):
-        """"""
-        pass
-
-    def GetMimeTypeFromExt(self):
-        """"""
-        pass
-
-    def GetProtocol(self):
-        """"""
-        pass
-
-    def GetRightLocation(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class InternetFSHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MemoryFSHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ZipFSHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Frames.py

@@ -1,519 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-from Window import TopLevelWindow, Window
-
-
-class Frame(TopLevelWindow):
-    """A frame is a window whose size and position can (usually) be
-    changed by the user. It usually has thick borders and a title bar,
-    and can optionally contain a menu bar, toolbar and status bar. A
-    frame can contain any window that is not a frame or dialog.
-
-    A frame that has a status bar and toolbar created via the
-    CreateStatusBar/CreateToolBar functions manages these windows, and
-    adjusts the value returned by GetClientSize to reflect the
-    remaining size available to application windows.
-
-    An application should normally define a CloseEvent handler for the
-    frame to respond to system close events, for example so that
-    related data and subwindows can be cleaned up."""
-
-    def __init__(self, parent, id, title, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
-                 name=wx.PyFrameNameStr):
-        """Create a Frame instance.
-
-        parent - The window parent.  This may be None.  If it is not
-        None, the frame will always be displayed on top of the parent
-        window on Windows.
-
-        id - The window identifier. It may take a value of -1 to
-        indicate a default value.
-
-        title - The caption to be displayed on the frame's title bar.
-
-        pos - The window position. A value of (-1, -1) indicates a
-        default position, chosen by either the windowing system or
-        wxWindows, depending on platform.
-
-        size - The window size. A value of (-1, -1) indicates a
-        default size, chosen by either the windowing system or
-        wxWindows, depending on platform.
-
-        style - The window style.
-
-        name - The name of the window. This parameter is used to
-        associate a name with the item, allowing the application user
-        to set Motif resource values for individual windows."""
-        pass
-
-    def Create(self, parent, id, title, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
-               name=wx.PyFrameNameStr):
-        """Create a Frame instance."""
-        pass
-
-    def Command(self, id):
-        """Simulate a menu command; id is a menu item identifier."""
-        pass
-
-    def CreateStatusBar(self, number=1, style=wx.ST_SIZEGRIP, id=-1,
-                        name=wx.PyStatusLineNameStr):
-        """Create a status bar at the bottom of frame.
-
-        number - The number of fields to create. Specify a value
-        greater than 1 to create a multi-field status bar.
-
-        style - The status bar style. See wx.StatusBar for a list of
-        valid styles.
-
-        id - The status bar window identifier. If -1, an identifier
-        will be chosen by wxWindows.
-
-        name - The status bar window name.
-
-        The width of the status bar is the whole width of the frame
-        (adjusted automatically when resizing), and the height and
-        text size are chosen by the host windowing system.
-
-        By default, the status bar is an instance of wx.StatusBar."""
-        pass
-
-    def CreateToolBar(self, style=wx.NO_BORDER | wx.TB_HORIZONTAL,
-                      id=-1, name=wx.PyToolBarNameStr):
-        """Create a toolbar at the top or left of frame.
-
-        style - The toolbar style. See wxToolBar for a list of valid
-        styles.
-
-        id - The toolbar window identifier. If -1, an identifier will
-        be chosen by wxWindows.
-
-        name - The toolbar window name.
-
-        By default, the toolbar is an instance of wx.ToolBar (which is
-        defined to be a suitable toolbar class on each platform, such
-        as wx.ToolBar95).
-
-        When a toolbar has been created with this function, or made
-        known to the frame with wx.Frame.SetToolBar, the frame will
-        manage the toolbar position and adjust the return value from
-        wx.Window.GetClientSize to reflect the available space for
-        application windows."""
-        pass
-
-    def DoGiveHelp(self, text, show):
-        """Show help text (typically in the statusbar).
-
-        show is False if you are hiding the help, True otherwise.
-
-        Meant to be overridden if a derived frame wants to do
-        something else with help text from menus and etc.  The default
-        implementation simply calls Frame.SetStatusText."""
-        pass
-
-    def GetClientAreaOrigin(self):
-        """Return origin of frame client area (in client coordinates).
-
-        It may be different from (0, 0) if the frame has a toolbar."""
-        pass
-
-    def GetMenuBar(self):
-        """Return menubar currently associated with frame (if any)."""
-        pass
-
-    def GetStatusBar(self):
-        """Return status bar currently associated with frame (if any)."""
-        pass
-
-    def GetStatusBarPane(self):
-        """Return status bar pane used to display menu/toolbar help."""
-        pass
-
-    def GetToolBar(self):
-        """Return toolbar currently associated with frame (if any)."""
-        pass
-
-    def PopStatusText(self, number=0):
-        """Redraw status bar with previous status text.
-
-        number - The status field (starting from zero)."""
-        pass
-
-    def ProcessCommand(self, id):
-        """Process menu command; return True if processed.
-
-        id is the menu command identifier."""
-        pass
-
-    def PushStatusText(self, text, number=0):
-        """Set status bar text and redraw status bar, remembering
-        previous text.
-
-        text - The text for the status field.
-
-        number - The status field (starting from zero).
-
-        Use an empty string to clear the status bar."""
-        pass
-
-    def SendSizeEvent(self):
-        """Send a dummy size event to the frame forcing it to
-        reevaluate its children positions. It is sometimes useful to
-        call this function after adding or deleting a children after
-        the frame creation or if a child size changes.
-
-        Note that if the frame is using either sizers or constraints
-        for the children layout, it is enough to call Frame.Layout()
-        directly and this function should not be used in this case."""
-        pass
-
-    def SetMenuBar(self, menubar):
-        """Show the menu bar in the frame.
-
-        menuBar - The menu bar to associate with the frame.
-
-        If the frame is destroyed, the menu bar and its menus will be
-        destroyed also, so do not delete the menu bar explicitly
-        (except by resetting the frame's menu bar to another frame or
-        NULL).
-
-        Under Windows, a call to Frame.OnSize is generated, so be sure
-        to initialize data members properly before calling SetMenuBar.
-
-        Note that it is not possible to call this function twice for
-        the same frame object."""
-        pass
-
-    def SetStatusBar(self, statBar):
-        """Associate a status bar with the frame."""
-        pass
-
-    def SetStatusBarPane(self, n):
-        """Set the status bar pane used to display menu and toolbar
-        help.  Using -1 disables help display."""
-        pass
-
-    def SetStatusText(self, text, number=0):
-        """Set status bar text and redraw status bar.
-
-        text - The text for the status field.
-
-        number - The status field (starting from zero).
-
-        Use an empty string to clear the status bar."""
-        pass
-
-    def SetStatusWidths(self, choices):
-        """Sets the widths of the fields in the status bar.
-
-        choices - a Python list of integers, each of which is a status
-        field width in pixels. A value of -1 indicates that the field
-        is variable width; at least one field must be -1.
-
-        The widths of the variable fields are calculated from the
-        total width of all fields, minus the sum of widths of the
-        non-variable fields, divided by the number of variable fields."""
-        pass
-
-    def SetToolBar(self, toolbar):
-        """Associate a toolbar with the frame."""
-        pass
-
-
-class LayoutAlgorithm(Object):
-    """LayoutAlgorithm implements layout of subwindows in MDI or SDI
-    frames.  It sends a wx.CalculateLayoutEvent event to children of
-    the frame, asking them for information about their size.  For MDI
-    parent frames, the algorithm allocates the remaining space to the
-    MDI client window (which contains the MDI child frames).  For SDI
-    (normal) frames, a 'main' window is specified as taking up the
-    remaining space.
-
-    Because the event system is used, this technique can be applied to
-    any windows, which are not necessarily 'aware' of the layout
-    classes.  However, you may wish to use wx.SashLayoutWindow for
-    your subwindows since this class provides handlers for the
-    required events, and accessors to specify the desired size of the
-    window.  The sash behaviour in the base class can be used,
-    optionally, to make the windows user-resizable.
-
-    LayoutAlgorithm is typically used in IDE (integrated development
-    environment) applications, where there are several resizable
-    windows in addition to the MDI client window, or other primary
-    editing window.  Resizable windows might include toolbars, a
-    project window, and a window for displaying error and warning
-    messages.
-
-    When a window receives an OnCalculateLayout event, it should call
-    SetRect in the given event object, to be the old supplied
-    rectangle minus whatever space the window takes up.  It should
-    also set its own size accordingly.
-    SashLayoutWindow.OnCalculateLayout generates an OnQueryLayoutInfo
-    event which it sends to itself to determine the orientation,
-    alignment and size of the window, which it gets from internal
-    member variables set by the application.
-
-    The algorithm works by starting off with a rectangle equal to the
-    whole frame client area.  It iterates through the frame children,
-    generating OnCalculateLayout events which subtract the window size
-    and return the remaining rectangle for the next window to process.
-    It is assumed (by SashLayoutWindow.OnCalculateLayout) that a
-    window stretches the full dimension of the frame client, according
-    to the orientation it specifies.  For example, a horizontal window
-    will stretch the full width of the remaining portion of the frame
-    client area.  In the other orientation, the window will be fixed
-    to whatever size was specified by OnQueryLayoutInfo.  An alignment
-    setting will make the window 'stick' to the left, top, right or
-    bottom of the remaining client area.  This scheme implies that
-    order of window creation is important.  Say you wish to have an
-    extra toolbar at the top of the frame, a project window to the
-    left of the MDI client window, and an output window above the
-    status bar.  You should therefore create the windows in this
-    order: toolbar, output window, project window.  This ensures that
-    the toolbar and output window take up space at the top and bottom,
-    and then the remaining height in-between is used for the project
-    window.
-
-    LayoutAlgorithm is quite independent of the way in which
-    OnCalculateLayout chooses to interpret a window's size and
-    alignment.  Therefore you could implement a different window class
-    with a new OnCalculateLayout event handler, that has a more
-    sophisticated way of laying out the windows.  It might allow
-    specification of whether stretching occurs in the specified
-    orientation, for example, rather than always assuming
-    stretching. (This could, and probably should, be added to the
-    existing implementation).
-
-    The algorithm object does not respond to events, but itself
-    generates the following events in order to calculate window sizes:
-    EVT_QUERY_LAYOUT_INFO(func), EVT_CALCULATE_LAYOUT(func)."""
-
-    def __init__(self):
-        """Create a LayoutAlgorithm instance."""
-        pass
-
-    def LayoutFrame(self, frame, mainWindow=wx.NULL):
-        """Lay out the children of a normal frame.
-
-        mainWindow is set to occupy the remaining space.  This
-        function simply calls LayoutWindow()."""
-        pass
-
-    def LayoutMDIFrame(self, frame, rect=wx.NULL):
-        """Lay out the children of an MDI parent frame.
-
-        If rect is non-NULL, the given rectangle will be used as a
-        starting point instead of the frame's client area.
-
-        The MDI client window is set to occupy the remaining space."""
-        pass
-
-    def LayoutWindow(self, parent, mainWindow=wx.NULL):
-        """Lay out the children of a normal frame or other window.
-
-        mainWindow is set to occupy the remaining space.  If this is
-        not specified, then the last window that responds to a
-        calculate layout event in query mode will get the remaining
-        space (that is, a non-query OnCalculateLayout event will not
-        be sent to this window and the window will be set to the
-        remaining size)."""
-        pass
-
-
-class MDIChildFrame(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def Activate(self):
-        """"""
-        pass
-
-    def Maximize(self):
-        """"""
-        pass
-
-    def Restore(self):
-        """"""
-        pass
-
-
-class MDIClientWindow(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-
-class MDIParentFrame(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def ActivateNext(self):
-        """"""
-        pass
-
-    def ActivatePrevious(self):
-        """"""
-        pass
-
-    def ArrangeIcons(self):
-        """"""
-        pass
-
-    def Cascade(self):
-        """"""
-        pass
-
-    def GetActiveChild(self):
-        """"""
-        pass
-
-    def GetClientWindow(self):
-        """"""
-        pass
-
-    def GetToolBar(self):
-        """"""
-        pass
-
-    def Tile(self):
-        """"""
-        pass
-
-
-class MiniFrame(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-
-class SplashScreen(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def GetSplashStyle(self):
-        """"""
-        pass
-
-    def GetSplashWindow(self):
-        """"""
-        pass
-
-    def GetTimeout(self):
-        """"""
-        pass
-
-
-class SplashScreenWindow(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def SetBitmap(self):
-        """"""
-        pass
-
-
-class StatusBar(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetBorderX(self):
-        """"""
-        pass
-
-    def GetBorderY(self):
-        """"""
-        pass
-
-    def GetFieldRect(self):
-        """"""
-        pass
-
-    def GetFieldsCount(self):
-        """"""
-        pass
-
-    def GetStatusText(self):
-        """"""
-        pass
-
-    def PopStatusText(self):
-        """"""
-        pass
-
-    def PushStatusText(self):
-        """"""
-        pass
-
-    def SetFieldsCount(self):
-        """"""
-        pass
-
-    def SetMinHeight(self):
-        """"""
-        pass
-
-    def SetStatusText(self):
-        """"""
-        pass
-
-    def SetStatusWidths(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/Help.py

@@ -1,127 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-from Window import Window
-
-
-class PopupWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def Position(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PopupTransientWindow(PopupWindow):
-    """"""
-
-    def Dismiss(self):
-        """"""
-        pass
-
-    def Popup(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TipProvider:
-    """"""
-
-    def GetCurrentTip(self):
-        """"""
-        pass
-
-    def GetTip(self):
-        """"""
-        pass
-
-    def PreprocessTip(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyTipProvider(TipProvider):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TipWindow(PopupTransientWindow):
-    """"""
-
-    def Close(self):
-        """"""
-        pass
-
-    def SetBoundingRect(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolTip(Object):
-    """"""
-
-    def GetTip(self):
-        """"""
-        pass
-
-    def GetWindow(self):
-        """"""
-        pass
-
-    def SetTip(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/ImageHandlers.py

@@ -1,142 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class ImageHandler(Object):
-    """"""
-
-    def CanRead(self):
-        """"""
-        pass
-
-    def GetExtension(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetName(self):
-        """"""
-        pass
-
-    def GetType(self):
-        """"""
-        pass
-
-    def SetExtension(self):
-        """"""
-        pass
-
-    def SetMimeType(self):
-        """"""
-        pass
-
-    def SetName(self):
-        """"""
-        pass
-
-    def SetType(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class BMPHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class GIFHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ICOHandler(BMPHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class CURHandler(ICOHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ANIHandler(CURHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class JPEGHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PCXHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PNGHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PNMHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class TIFFHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Joystick.py

@@ -1,197 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class Joystick(Object):
-    """"""
-
-    def GetButtonState(self):
-        """"""
-        pass
-
-    def GetManufacturerId(self):
-        """"""
-        pass
-
-    def GetMaxAxes(self):
-        """"""
-        pass
-
-    def GetMaxButtons(self):
-        """"""
-        pass
-
-    def GetMovementThreshold(self):
-        """"""
-        pass
-
-    def GetNumberAxes(self):
-        """"""
-        pass
-
-    def GetNumberButtons(self):
-        """"""
-        pass
-
-    def GetNumberJoysticks(self):
-        """"""
-        pass
-
-    def GetPOVCTSPosition(self):
-        """"""
-        pass
-
-    def GetPOVPosition(self):
-        """"""
-        pass
-
-    def GetPollingMax(self):
-        """"""
-        pass
-
-    def GetPollingMin(self):
-        """"""
-        pass
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetProductId(self):
-        """"""
-        pass
-
-    def GetProductName(self):
-        """"""
-        pass
-
-    def GetRudderMax(self):
-        """"""
-        pass
-
-    def GetRudderMin(self):
-        """"""
-        pass
-
-    def GetRudderPosition(self):
-        """"""
-        pass
-
-    def GetUMax(self):
-        """"""
-        pass
-
-    def GetUMin(self):
-        """"""
-        pass
-
-    def GetUPosition(self):
-        """"""
-        pass
-
-    def GetVMax(self):
-        """"""
-        pass
-
-    def GetVMin(self):
-        """"""
-        pass
-
-    def GetVPosition(self):
-        """"""
-        pass
-
-    def GetXMax(self):
-        """"""
-        pass
-
-    def GetXMin(self):
-        """"""
-        pass
-
-    def GetYMax(self):
-        """"""
-        pass
-
-    def GetYMin(self):
-        """"""
-        pass
-
-    def GetZMax(self):
-        """"""
-        pass
-
-    def GetZMin(self):
-        """"""
-        pass
-
-    def GetZPosition(self):
-        """"""
-        pass
-
-    def HasPOV(self):
-        """"""
-        pass
-
-    def HasPOV4Dir(self):
-        """"""
-        pass
-
-    def HasPOVCTS(self):
-        """"""
-        pass
-
-    def HasRudder(self):
-        """"""
-        pass
-
-    def HasU(self):
-        """"""
-        pass
-
-    def HasV(self):
-        """"""
-        pass
-
-    def HasZ(self):
-        """"""
-        pass
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def ReleaseCapture(self):
-        """"""
-        pass
-
-    def SetCapture(self):
-        """"""
-        pass
-
-    def SetMovementThreshold(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/LayoutConstraints.py

@@ -1,80 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class IndividualLayoutConstraint(Object):
-    """"""
-
-    def Above(self):
-        """"""
-        pass
-
-    def Absolute(self):
-        """"""
-        pass
-
-    def AsIs(self):
-        """"""
-        pass
-
-    def Below(self):
-        """"""
-        pass
-
-    def LeftOf(self):
-        """"""
-        pass
-
-    def PercentOf(self):
-        """"""
-        pass
-
-    def RightOf(self):
-        """"""
-        pass
-
-    def SameAs(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def Unconstrained(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LayoutConstraints(Object):
-    """"""
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/Logging.py

@@ -1,145 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class Log:
-    """"""
-
-    def Flush(self):
-        """"""
-        pass
-
-    def GetVerbose(self):
-        """"""
-        pass
-
-    def HasPendingMessages(self):
-        """"""
-        pass
-
-    def TimeStamp(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyLog(Log):
-    """"""
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class LogChain(Log):
-    """"""
-
-    def GetOldLog(self):
-        """"""
-        pass
-
-    def IsPassingMessages(self):
-        """"""
-        pass
-
-    def PassMessages(self):
-        """"""
-        pass
-
-    def SetLog(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogGui(Log):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogNull:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogStderr(Log):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogTextCtrl(Log):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogWindow(Log):
-    """"""
-
-    def GetFrame(self):
-        """"""
-        pass
-
-    def GetOldLog(self):
-        """"""
-        pass
-
-    def IsPassingMessages(self):
-        """"""
-        pass
-
-    def PassMessages(self):
-        """"""
-        pass
-
-    def Show(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Menus.py

@@ -1,477 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object, EvtHandler
-import Parameters as wx
-from Window import Window
-
-
-class FileHistory(Object):
-    """"""
-
-    def AddFileToHistory(self):
-        """"""
-        pass
-
-    def AddFilesToMenu(self):
-        """"""
-        pass
-
-    def AddFilesToThisMenu(self):
-        """"""
-        pass
-
-    def GetCount(self):
-        """"""
-        pass
-
-    def GetHistoryFile(self):
-        """"""
-        pass
-
-    def GetMaxFiles(self):
-        """"""
-        pass
-
-    def GetNoHistoryFiles(self):
-        """"""
-        pass
-
-    def Load(self):
-        """"""
-        pass
-
-    def RemoveFileFromHistory(self):
-        """"""
-        pass
-
-    def RemoveMenu(self):
-        """"""
-        pass
-
-    def Save(self):
-        """"""
-        pass
-
-    def UseMenu(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Menu(EvtHandler):
-    """"""
-
-    def Append(self):
-        """"""
-        pass
-
-    def AppendCheckItem(self):
-        """"""
-        pass
-
-    def AppendItem(self):
-        """"""
-        pass
-
-    def AppendMenu(self):
-        """"""
-        pass
-
-    def AppendRadioItem(self):
-        """"""
-        pass
-
-    def AppendSeparator(self):
-        """"""
-        pass
-
-    def Break(self):
-        """"""
-        pass
-
-    def Check(self):
-        """"""
-        pass
-
-    def Delete(self):
-        """"""
-        pass
-
-    def DeleteItem(self):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def DestroyId(self):
-        """"""
-        pass
-
-    def DestroyItem(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def FindItem(self):
-        """"""
-        pass
-
-    def FindItemById(self):
-        """"""
-        pass
-
-    def GetEventHandler(self):
-        """"""
-        pass
-
-    def GetHelpString(self):
-        """"""
-        pass
-
-    def GetInvokingWindow(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetMenuItemCount(self):
-        """"""
-        pass
-
-    def GetMenuItems(self):
-        """"""
-        pass
-
-    def GetParent(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetTitle(self):
-        """"""
-        pass
-
-    def Insert(self):
-        """"""
-        pass
-
-    def InsertCheckItem(self):
-        """"""
-        pass
-
-    def InsertItem(self):
-        """"""
-        pass
-
-    def InsertMenu(self):
-        """"""
-        pass
-
-    def InsertRadioItem(self):
-        """"""
-        pass
-
-    def InsertSeparator(self):
-        """"""
-        pass
-
-    def IsAttached(self):
-        """"""
-        pass
-
-    def IsChecked(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def Prepend(self):
-        """"""
-        pass
-
-    def PrependCheckItem(self):
-        """"""
-        pass
-
-    def PrependItem(self):
-        """"""
-        pass
-
-    def PrependMenu(self):
-        """"""
-        pass
-
-    def PrependRadioItem(self):
-        """"""
-        pass
-
-    def PrependSeparator(self):
-        """"""
-        pass
-
-    def Remove(self):
-        """"""
-        pass
-
-    def RemoveItem(self):
-        """"""
-        pass
-
-    def SetEventHandler(self):
-        """"""
-        pass
-
-    def SetHelpString(self):
-        """"""
-        pass
-
-    def SetInvokingWindow(self):
-        """"""
-        pass
-
-    def SetLabel(self):
-        """"""
-        pass
-
-    def SetParent(self):
-        """"""
-        pass
-
-    def SetTitle(self):
-        """"""
-        pass
-
-    def UpdateUI(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MenuBar(Window):
-    """"""
-
-    def Append(self):
-        """"""
-        pass
-
-    def Check(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def EnableTop(self):
-        """"""
-        pass
-
-    def FindItemById(self):
-        """"""
-        pass
-
-    def FindMenu(self):
-        """"""
-        pass
-
-    def FindMenuItem(self):
-        """"""
-        pass
-
-    def GetHelpString(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetLabelTop(self):
-        """"""
-        pass
-
-    def GetMenu(self):
-        """"""
-        pass
-
-    def GetMenuCount(self):
-        """"""
-        pass
-
-    def Insert(self):
-        """"""
-        pass
-
-    def IsChecked(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsEnabledTop(self):
-        """"""
-        pass
-
-    def Remove(self):
-        """"""
-        pass
-
-    def Replace(self):
-        """"""
-        pass
-
-    def SetHelpString(self):
-        """"""
-        pass
-
-    def SetLabel(self):
-        """"""
-        pass
-
-    def SetLabelTop(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-class MenuItem(Object):
-    """"""
-
-    def Check(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def GetAccel(self):
-        """"""
-        pass
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def GetHelp(self):
-        """"""
-        pass
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetKind(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetMenu(self):
-        """"""
-        pass
-
-    def GetSubMenu(self):
-        """"""
-        pass
-
-    def GetText(self):
-        """"""
-        pass
-
-    def IsCheckable(self):
-        """"""
-        pass
-
-    def IsChecked(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsSeparator(self):
-        """"""
-        pass
-
-    def IsSubMenu(self):
-        """"""
-        pass
-
-    def SetAccel(self):
-        """"""
-        pass
-
-    def SetBitmap(self):
-        """"""
-        pass
-
-    def SetCheckable(self):
-        """"""
-        pass
-
-    def SetHelp(self):
-        """"""
-        pass
-
-    def SetId(self):
-        """"""
-        pass
-
-    def SetSubMenu(self):
-        """"""
-        pass
-
-    def SetText(self):
-        """"""
-        pass
-
-    def Toggle(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/MimeTypes.py

@@ -1,185 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class FileType:
-    """"""
-
-    def GetAllCommands(self):
-        """"""
-        pass
-
-    def GetDescription(self):
-        """"""
-        pass
-
-    def GetExtensions(self):
-        """"""
-        pass
-
-    def GetIcon(self):
-        """"""
-        pass
-
-    def GetIconInfo(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetMimeTypes(self):
-        """"""
-        pass
-
-    def GetOpenCommand(self):
-        """"""
-        pass
-
-    def GetPrintCommand(self):
-        """"""
-        pass
-
-    def SetCommand(self):
-        """"""
-        pass
-
-    def SetDefaultIcon(self):
-        """"""
-        pass
-
-    def Unassociate(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileTypeInfo:
-    """"""
-
-    def GetDescription(self):
-        """"""
-        pass
-
-    def GetExtensions(self):
-        """"""
-        pass
-
-    def GetExtensionsCount(self):
-        """"""
-        pass
-
-    def GetIconFile(self):
-        """"""
-        pass
-
-    def GetIconIndex(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetOpenCommand(self):
-        """"""
-        pass
-
-    def GetPrintCommand(self):
-        """"""
-        pass
-
-    def GetShortDesc(self):
-        """"""
-        pass
-
-    def IsValid(self):
-        """"""
-        pass
-
-    def SetIcon(self):
-        """"""
-        pass
-
-    def SetShortDesc(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MimeTypesManager:
-    """"""
-
-    def AddFallback(self):
-        """"""
-        pass
-
-    def Associate(self):
-        """"""
-        pass
-
-    def ClearData(self):
-        """"""
-        pass
-
-    def EnumAllFileTypes(self):
-        """"""
-        pass
-
-    def GetFileTypeFromExtension(self):
-        """"""
-        pass
-
-    def GetFileTypeFromMimeType(self):
-        """"""
-        pass
-
-    def Initialize(self):
-        """"""
-        pass
-
-    def ReadMailcap(self):
-        """"""
-        pass
-
-    def ReadMimeTypes(self):
-        """"""
-        pass
-
-    def Unassociate(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Misc.py

@@ -1,558 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class ArtProvider(Object):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class BusyCursor:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class BusyInfo(Object):
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Caret:
-    """"""
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetPositionTuple(self):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def GetSizeTuple(self):
-        """"""
-        pass
-
-    def GetWindow(self):
-        """"""
-        pass
-
-    def Hide(self):
-        """"""
-        pass
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def IsVisible(self):
-        """"""
-        pass
-
-    def Move(self):
-        """"""
-        pass
-
-    def MoveXY(self):
-        """"""
-        pass
-
-    def SetSize(self):
-        """"""
-        pass
-
-    def SetSizeWH(self):
-        """"""
-        pass
-
-    def Show(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class EncodingConverter(Object):
-    """"""
-
-    def Convert(self):
-        """"""
-        pass
-
-    def Init(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DirItemData(Object):
-    """"""
-
-    def SetNewDirName(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-
-class Effects(Object):
-    """"""
-
-    def DrawSunkenEdge(self):
-        """"""
-        pass
-
-    def GetDarkShadow(self):
-        """"""
-        pass
-
-    def GetFaceColour(self):
-        """"""
-        pass
-
-    def GetHighlightColour(self):
-        """"""
-        pass
-
-    def GetLightShadow(self):
-        """"""
-        pass
-
-    def GetMediumShadow(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def SetDarkShadow(self):
-        """"""
-        pass
-
-    def SetFaceColour(self):
-        """"""
-        pass
-
-    def SetHighlightColour(self):
-        """"""
-        pass
-
-    def SetLightShadow(self):
-        """"""
-        pass
-
-    def SetMediumShadow(self):
-        """"""
-        pass
-
-    def TileBitmap(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FontEnumerator:
-    """"""
-
-    def EnumerateEncodings(self):
-        """"""
-        pass
-
-    def EnumerateFacenames(self):
-        """"""
-        pass
-
-    def GetEncodings(self):
-        """"""
-        pass
-
-    def GetFacenames(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class FontMapper:
-    """"""
-
-    def CharsetToEncoding(self):
-        """"""
-        pass
-
-    def GetAltForEncoding(self):
-        """"""
-        pass
-
-    def IsEncodingAvailable(self):
-        """"""
-        pass
-
-    def SetConfig(self):
-        """"""
-        pass
-
-    def SetConfigPath(self):
-        """"""
-        pass
-
-    def SetDialogParent(self):
-        """"""
-        pass
-
-    def SetDialogTitle(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LanguageInfo:
-    """"""
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-
-class Locale:
-    """"""
-
-    def AddCatalog(self):
-        """"""
-        pass
-
-    def GetCanonicalName(self):
-        """"""
-        pass
-
-    def GetLanguage(self):
-        """"""
-        pass
-
-    def GetLocale(self):
-        """"""
-        pass
-
-    def GetName(self):
-        """"""
-        pass
-
-    def GetString(self):
-        """"""
-        pass
-
-    def GetSysName(self):
-        """"""
-        pass
-
-    def Init(self):
-        """"""
-        pass
-
-    def IsLoaded(self):
-        """"""
-        pass
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class NativeFontInfo:
-    """"""
-
-    def FromString(self):
-        """"""
-        pass
-
-    def FromUserString(self):
-        """"""
-        pass
-
-    def GetEncoding(self):
-        """"""
-        pass
-
-    def GetFaceName(self):
-        """"""
-        pass
-
-    def GetFamily(self):
-        """"""
-        pass
-
-    def GetPointSize(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetUnderlined(self):
-        """"""
-        pass
-
-    def GetWeight(self):
-        """"""
-        pass
-
-    def Init(self):
-        """"""
-        pass
-
-    def SetEncoding(self):
-        """"""
-        pass
-
-    def SetFaceName(self):
-        """"""
-        pass
-
-    def SetFamily(self):
-        """"""
-        pass
-
-    def SetPointSize(self):
-        """"""
-        pass
-
-    def SetStyle(self):
-        """"""
-        pass
-
-    def SetUnderlined(self):
-        """"""
-        pass
-
-    def SetWeight(self):
-        """"""
-        pass
-
-    def ToString(self):
-        """"""
-        pass
-
-    def ToUserString(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-
-class PyTimer(Object):
-    """"""
-
-    def GetInterval(self):
-        """"""
-        pass
-
-    def IsOneShot(self):
-        """"""
-        pass
-
-    def IsRunning(self):
-        """"""
-        pass
-
-    def SetOwner(self):
-        """"""
-        pass
-
-    def Start(self):
-        """"""
-        pass
-
-    def Stop(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class StopWatch:
-    """"""
-
-    def Pause(self):
-        """"""
-        pass
-
-    def Resume(self):
-        """"""
-        pass
-
-    def Start(self):
-        """"""
-        pass
-
-    def Time(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SystemSettings:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Timer(PyTimer):
-    """"""
-
-    def __init__(self, evtHandler=None, id=-1):
-        """Create a Timer instance."""
-        pass
-
-
-class Wave(Object):
-    """"""
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def Play(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class WindowDisabler:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Panel.py

@@ -1,240 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-from Window import Window
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Panel(Window):
-    """"""
-
-    def __init__(self, parent, id, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.TAB_TRAVERSAL,
-                 name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def Create(self, parent, id, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=wx.TAB_TRAVERSAL,
-               name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def InitDialog(self):
-        """"""
-        pass
-
-
-class PyPanel(Panel):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_AcceptsFocus(self):
-        """"""
-        pass
-
-    def base_AcceptsFocusFromKeyboard(self):
-        """"""
-        pass
-
-    def base_AddChild(self):
-        """"""
-        pass
-
-    def base_DoGetBestSize(self):
-        """"""
-        pass
-
-    def base_DoGetClientSize(self):
-        """"""
-        pass
-
-    def base_DoGetPosition(self):
-        """"""
-        pass
-
-    def base_DoGetSize(self):
-        """"""
-        pass
-
-    def base_DoGetVirtualSize(self):
-        """"""
-        pass
-
-    def base_DoMoveWindow(self):
-        """"""
-        pass
-
-    def base_DoSetClientSize(self):
-        """"""
-        pass
-
-    def base_DoSetSize(self):
-        """"""
-        pass
-
-    def base_DoSetVirtualSize(self):
-        """"""
-        pass
-
-    def base_GetMaxSize(self):
-        """"""
-        pass
-
-    def base_InitDialog(self):
-        """"""
-        pass
-
-    def base_RemoveChild(self):
-        """"""
-        pass
-
-    def base_TransferDataFromWindow(self):
-        """"""
-        pass
-
-    def base_TransferDataToWindow(self):
-        """"""
-        pass
-
-    def base_Validate(self):
-        """"""
-        pass
-
-
-class ScrolledWindow(Panel):
-    """"""
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.HSCROLL|wx.VSCROLL,
-                 name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def Create(self, parent, id=-1, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=wx.HSCROLL|wx.VSCROLL,
-               name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def AdjustScrollbars(self):
-        """"""
-        pass
-
-    def CalcScrolledPosition(self, *args):
-        """*args can be a point or (x, y) tuple"""
-        pass
-
-    def CalcScrolledPosition1(self, pt):
-        """"""
-        pass
-
-    def CalcScrolledPosition2(self, x, y):
-        """"""
-        pass
-
-    def CalcUnscrolledPosition(self, *args):
-        """*args can be a point or (x, y) tuple"""
-        pass
-
-    def CalcUnscrolledPosition1(self, pt):
-        """"""
-        pass
-
-    def CalcUnscrolledPosition2(self, x, y):
-        """"""
-        pass
-
-    def EnableScrolling(self, xScrolling, yScrolling):
-        """"""
-        pass
-
-    def GetScaleX(self):
-        """"""
-        pass
-
-    def GetScaleY(self):
-        """"""
-        pass
-
-    def GetScrollPageSize(self, orient):
-        """"""
-        pass
-
-    def GetScrollPixelsPerUnit(self):
-        """"""
-        pass
-
-    def GetTargetWindow(self):
-        """"""
-        pass
-
-    def GetViewStart(self):
-        """"""
-        pass
-
-    def IsRetained(self):
-        """"""
-        pass
-
-    def Layout(self):
-        """"""
-        pass
-
-    def PrepareDC(self, dc):
-        """"""
-        pass
-
-    def Scroll(self, x, y):
-        """"""
-        pass
-
-    def SetScale(self, xs, ys):
-        """"""
-        pass
-
-    def SetScrollPageSize(self, orient, pageSize):
-        """"""
-        pass
-
-    def SetScrollRate(self, xstep, ystep):
-        """Set the x, y scrolling increments."""
-        pass
-
-    def SetScrollbars(self, pixelsPerUnitX, pixelsPerUnitY,
-                      noUnitsX, noUnitsY, xPos=0, yPos=0, noRefresh=False):
-        """"""
-        pass
-
-    def SetTargetWindow(self, window):
-        """"""
-        pass
-
-    def ViewStart(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Parameters.py

@@ -1,69 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class _Param:
-    """Used by this module to represent default wxPython parameter values,
-    including parameter representations like style=wx.HSCROLL|wx.VSCROLL."""
-
-    def __init__(self, value=None):
-        if value is None:
-            value = 'wx.' + self.__class__.__name__
-        self.value = value
-
-    def __repr__(self):
-        return self.value
-
-    def __or__(self, other):
-        value = '%s|%s' % (self, other)
-        return self.__class__(value)
-
-_params = (
-    'BOTH',
-    'DEFAULT_FRAME_STYLE',
-    'DefaultPosition',
-    'DefaultSize',
-    'DefaultValidator',
-    'EmptyString',
-    'EVT_NULL',
-    'HORIZONTAL',
-    'HSCROLL',
-    'NO_BORDER',
-    'NULL',
-    'NullColour',
-    'PyFrameNameStr',
-    'PyNOTEBOOK_NAME',
-    'PyPanelNameStr',
-    'PyStatusLineNameStr',
-    'PySTCNameStr',
-    'PyToolBarNameStr',
-    'SIZE_AUTO',
-    'SIZE_USE_EXISTING',
-    'ST_SIZEGRIP',
-    'TAB_TRAVERSAL',
-    'TB_HORIZONTAL',
-    'VSCROLL',
-    )
-
-## Create classes, then instances, like this:
-
-## class BOTH(Param): pass
-## BOTH = BOTH()
-
-for _param in _params:
-    exec 'class %s(_Param): pass' % _param
-    exec '%s = %s()' % (_param, _param)
-
-del _param
-del _params
-del _Param

wxPython/wxPython/py/wxd/Printing.py

@@ -1,651 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Dialogs import Dialog
-from Frames import Frame
-import Parameters as wx
-
-
-class PageSetupDialog(Dialog):
-    """"""
-
-    def GetPageSetupData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PageSetupDialogData(Object):
-    """"""
-
-    def EnableHelp(self):
-        """"""
-        pass
-
-    def EnableMargins(self):
-        """"""
-        pass
-
-    def EnableOrientation(self):
-        """"""
-        pass
-
-    def EnablePaper(self):
-        """"""
-        pass
-
-    def EnablePrinter(self):
-        """"""
-        pass
-
-    def GetDefaultInfo(self):
-        """"""
-        pass
-
-    def GetDefaultMinMargins(self):
-        """"""
-        pass
-
-    def GetEnableHelp(self):
-        """"""
-        pass
-
-    def GetEnableMargins(self):
-        """"""
-        pass
-
-    def GetEnableOrientation(self):
-        """"""
-        pass
-
-    def GetEnablePaper(self):
-        """"""
-        pass
-
-    def GetEnablePrinter(self):
-        """"""
-        pass
-
-    def GetMarginBottomRight(self):
-        """"""
-        pass
-
-    def GetMarginTopLeft(self):
-        """"""
-        pass
-
-    def GetMinMarginBottomRight(self):
-        """"""
-        pass
-
-    def GetMinMarginTopLeft(self):
-        """"""
-        pass
-
-    def GetPaperId(self):
-        """"""
-        pass
-
-    def GetPaperSize(self):
-        """"""
-        pass
-
-    def GetPrintData(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def SetDefaultInfo(self):
-        """"""
-        pass
-
-    def SetDefaultMinMargins(self):
-        """"""
-        pass
-
-    def SetMarginBottomRight(self):
-        """"""
-        pass
-
-    def SetMarginTopLeft(self):
-        """"""
-        pass
-
-    def SetMinMarginBottomRight(self):
-        """"""
-        pass
-
-    def SetMinMarginTopLeft(self):
-        """"""
-        pass
-
-    def SetPaperId(self):
-        """"""
-        pass
-
-    def SetPaperSize(self):
-        """"""
-        pass
-
-    def SetPrintData(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintDialog(Dialog):
-    """"""
-
-    def GetPrintDC(self):
-        """"""
-        pass
-
-    def GetPrintDialogData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintDialogData(Object):
-    """"""
-
-    def EnableHelp(self):
-        """"""
-        pass
-
-    def EnablePageNumbers(self):
-        """"""
-        pass
-
-    def EnablePrintToFile(self):
-        """"""
-        pass
-
-    def EnableSelection(self):
-        """"""
-        pass
-
-    def GetAllPages(self):
-        """"""
-        pass
-
-    def GetCollate(self):
-        """"""
-        pass
-
-    def GetFromPage(self):
-        """"""
-        pass
-
-    def GetMaxPage(self):
-        """"""
-        pass
-
-    def GetMinPage(self):
-        """"""
-        pass
-
-    def GetNoCopies(self):
-        """"""
-        pass
-
-    def GetPrintData(self):
-        """"""
-        pass
-
-    def GetPrintToFile(self):
-        """"""
-        pass
-
-    def GetToPage(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def SetCollate(self):
-        """"""
-        pass
-
-    def SetFromPage(self):
-        """"""
-        pass
-
-    def SetMaxPage(self):
-        """"""
-        pass
-
-    def SetMinPage(self):
-        """"""
-        pass
-
-    def SetNoCopies(self):
-        """"""
-        pass
-
-    def SetPrintData(self):
-        """"""
-        pass
-
-    def SetPrintToFile(self):
-        """"""
-        pass
-
-    def SetSetupDialog(self):
-        """"""
-        pass
-
-    def SetToPage(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PreviewFrame(Frame):
-    """"""
-
-    def Initialize(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintData(Object):
-    """"""
-
-    def GetCollate(self):
-        """"""
-        pass
-
-    def GetColour(self):
-        """"""
-        pass
-
-    def GetDuplex(self):
-        """"""
-        pass
-
-    def GetFilename(self):
-        """"""
-        pass
-
-    def GetFontMetricPath(self):
-        """"""
-        pass
-
-    def GetNoCopies(self):
-        """"""
-        pass
-
-    def GetOrientation(self):
-        """"""
-        pass
-
-    def GetPaperId(self):
-        """"""
-        pass
-
-    def GetPaperSize(self):
-        """"""
-        pass
-
-    def GetPreviewCommand(self):
-        """"""
-        pass
-
-    def GetPrintMode(self):
-        """"""
-        pass
-
-    def GetPrinterCommand(self):
-        """"""
-        pass
-
-    def GetPrinterName(self):
-        """"""
-        pass
-
-    def GetPrinterOptions(self):
-        """"""
-        pass
-
-    def GetPrinterScaleX(self):
-        """"""
-        pass
-
-    def GetPrinterScaleY(self):
-        """"""
-        pass
-
-    def GetPrinterTranslateX(self):
-        """"""
-        pass
-
-    def GetPrinterTranslateY(self):
-        """"""
-        pass
-
-    def GetQuality(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def SetCollate(self):
-        """"""
-        pass
-
-    def SetColour(self):
-        """"""
-        pass
-
-    def SetDuplex(self):
-        """"""
-        pass
-
-    def SetFilename(self):
-        """"""
-        pass
-
-    def SetFontMetricPath(self):
-        """"""
-        pass
-
-    def SetNoCopies(self):
-        """"""
-        pass
-
-    def SetOrientation(self):
-        """"""
-        pass
-
-    def SetPaperId(self):
-        """"""
-        pass
-
-    def SetPaperSize(self):
-        """"""
-        pass
-
-    def SetPreviewCommand(self):
-        """"""
-        pass
-
-    def SetPrintMode(self):
-        """"""
-        pass
-
-    def SetPrinterCommand(self):
-        """"""
-        pass
-
-    def SetPrinterName(self):
-        """"""
-        pass
-
-    def SetPrinterOptions(self):
-        """"""
-        pass
-
-    def SetPrinterScaleX(self):
-        """"""
-        pass
-
-    def SetPrinterScaleY(self):
-        """"""
-        pass
-
-    def SetPrinterScaling(self):
-        """"""
-        pass
-
-    def SetPrinterTranslateX(self):
-        """"""
-        pass
-
-    def SetPrinterTranslateY(self):
-        """"""
-        pass
-
-    def SetPrinterTranslation(self):
-        """"""
-        pass
-
-    def SetQuality(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintPreview(Object):
-    """"""
-
-    def GetCanvas(self):
-        """"""
-        pass
-
-    def GetCurrentPage(self):
-        """"""
-        pass
-
-    def GetFrame(self):
-        """"""
-        pass
-
-    def GetMaxPage(self):
-        """"""
-        pass
-
-    def GetMinPage(self):
-        """"""
-        pass
-
-    def GetPrintDialogData(self):
-        """"""
-        pass
-
-    def GetPrintout(self):
-        """"""
-        pass
-
-    def GetPrintoutForPrinting(self):
-        """"""
-        pass
-
-    def GetZoom(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def Print(self):
-        """"""
-        pass
-
-    def SetCanvas(self):
-        """"""
-        pass
-
-    def SetCurrentPage(self):
-        """"""
-        pass
-
-    def SetFrame(self):
-        """"""
-        pass
-
-    def SetPrintout(self):
-        """"""
-        pass
-
-    def SetZoom(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Printer(Object):
-    """"""
-
-    def CreateAbortWindow(self):
-        """"""
-        pass
-
-    def GetPrintDialogData(self):
-        """"""
-        pass
-
-    def Print(self):
-        """"""
-        pass
-
-    def PrintDialog(self):
-        """"""
-        pass
-
-    def ReportError(self):
-        """"""
-        pass
-
-    def Setup(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Printout(Object):
-    """"""
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def GetDC(self):
-        """"""
-        pass
-
-    def GetPPIPrinter(self):
-        """"""
-        pass
-
-    def GetPPIScreen(self):
-        """"""
-        pass
-
-    def GetPageSizeMM(self):
-        """"""
-        pass
-
-    def GetPageSizePixels(self):
-        """"""
-        pass
-
-    def IsPreview(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_GetPageInfo(self):
-        """"""
-        pass
-
-    def base_HasPage(self):
-        """"""
-        pass
-
-    def base_OnBeginDocument(self):
-        """"""
-        pass
-
-    def base_OnBeginPrinting(self):
-        """"""
-        pass
-
-    def base_OnEndDocument(self):
-        """"""
-        pass
-
-    def base_OnEndPrinting(self):
-        """"""
-        pass
-
-    def base_OnPreparePrinting(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Process.py

@@ -1,77 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-
-
-class Process(EvtHandler):
-    """"""
-
-    def CloseOutput(self):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def Detach(self):
-        """"""
-        pass
-
-    def GetErrorStream(self):
-        """"""
-        pass
-
-    def GetInputStream(self):
-        """"""
-        pass
-
-    def GetOutputStream(self):
-        """"""
-        pass
-
-    def IsErrorAvailable(self):
-        """"""
-        pass
-
-    def IsInputAvailable(self):
-        """"""
-        pass
-
-    def IsInputOpened(self):
-        """"""
-        pass
-
-    def IsRedirected(self):
-        """"""
-        pass
-
-    def Redirect(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnTerminate(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/SashSplitter.py

@@ -1,226 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-from Window import Window
-
-
-class SashWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetDefaultBorderSize(self):
-        """"""
-        pass
-
-    def GetEdgeMargin(self):
-        """"""
-        pass
-
-    def GetExtraBorderSize(self):
-        """"""
-        pass
-
-    def GetMaximumSizeX(self):
-        """"""
-        pass
-
-    def GetMaximumSizeY(self):
-        """"""
-        pass
-
-    def GetMinimumSizeX(self):
-        """"""
-        pass
-
-    def GetMinimumSizeY(self):
-        """"""
-        pass
-
-    def GetSashVisible(self):
-        """"""
-        pass
-
-    def HasBorder(self):
-        """"""
-        pass
-
-    def SetDefaultBorderSize(self):
-        """"""
-        pass
-
-    def SetExtraBorderSize(self):
-        """"""
-        pass
-
-    def SetMaximumSizeX(self):
-        """"""
-        pass
-
-    def SetMaximumSizeY(self):
-        """"""
-        pass
-
-    def SetMinimumSizeX(self):
-        """"""
-        pass
-
-    def SetMinimumSizeY(self):
-        """"""
-        pass
-
-    def SetSashBorder(self):
-        """"""
-        pass
-
-    def SetSashVisible(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SashLayoutWindow(SashWindow):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetAlignment(self):
-        """"""
-        pass
-
-    def GetOrientation(self):
-        """"""
-        pass
-
-    def SetAlignment(self):
-        """"""
-        pass
-
-    def SetDefaultSize(self):
-        """"""
-        pass
-
-    def SetOrientation(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SplitterWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetBorderSize(self):
-        """"""
-        pass
-
-    def GetMinimumPaneSize(self):
-        """"""
-        pass
-
-    def GetNeedUpdating(self):
-        """"""
-        pass
-
-    def GetSashPosition(self):
-        """"""
-        pass
-
-    def GetSashSize(self):
-        """"""
-        pass
-
-    def GetSplitMode(self):
-        """"""
-        pass
-
-    def GetWindow1(self):
-        """"""
-        pass
-
-    def GetWindow2(self):
-        """"""
-        pass
-
-    def Initialize(self):
-        """"""
-        pass
-
-    def IsSplit(self):
-        """"""
-        pass
-
-    def ReplaceWindow(self):
-        """"""
-        pass
-
-    def SetBorderSize(self):
-        """"""
-        pass
-
-    def SetMinimumPaneSize(self):
-        """"""
-        pass
-
-    def SetNeedUpdating(self):
-        """"""
-        pass
-
-    def SetSashPosition(self):
-        """"""
-        pass
-
-    def SetSashSize(self):
-        """"""
-        pass
-
-    def SetSplitMode(self):
-        """"""
-        pass
-
-    def SizeWindows(self):
-        """"""
-        pass
-
-    def SplitHorizontally(self):
-        """"""
-        pass
-
-    def SplitVertically(self):
-        """"""
-        pass
-
-    def Unsplit(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Sizers.py

@@ -1,605 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-
-Sizer is the abstract base class used for laying out subwindows in a
-window.  You cannot use Sizer directly; instead, you will have to use
-one of the sizer classes derived from it.  Currently there are
-BoxSizer, StaticBoxSizer, NotebookSizer, GridSizer, and FlexGridSizer.
-
-The layout algorithm used by sizers in wxPython is closely related to
-layout in other GUI toolkits, such as Java's AWT, the GTK toolkit or
-the Qt toolkit.  It is based upon the idea of the individual
-subwindows reporting their minimal required size and their ability to
-get stretched if the size of the parent window has changed.  This will
-most often mean, that the programmer does not set the original size of
-a dialog in the beginning, rather the dialog will assigned a sizer and
-this sizer will be queried about the recommended size.  The sizer in
-turn will query its children, which can be normal windows, empty space
-or other sizers, so that a hierarchy of sizers can be constructed.
-Note that wxSizer does not derive from wxWindow and thus do not
-interfere with tab ordering and requires very little resources
-compared to a real window on screen.
-
-What makes sizers so well fitted for use in wxPython is the fact that
-every control reports its own minimal size and the algorithm can
-handle differences in font sizes or different window (dialog item)
-sizes on different platforms without problems.  If e.g. the standard
-font as well as the overall design of Motif widgets requires more
-space than on Windows, the initial dialog size will automatically be
-bigger on Motif than on Windows.
-
-If you wish to create a sizer class in wxPython you should derive the
-class from PySizer in order to get Python-aware capabilities for the
-various virtual methods.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Sizer(Object):
-    """Sizer is the abstract base class used for laying out subwindows
-    in a window. You shouldn't use Sizer directly; instead, you should
-    use one of the sizer classes derived from it.
-
-    If you wish to create a sizer class in wxPython you should derive
-    the class from PySizer in order to get Python-aware capabilities
-    for the various virtual methods.
-
-    Placing a child sizer in a sizer allows you to create hierarchies
-    of sizers (typically a vertical box as the top sizer and several
-    horizontal boxes on the level beneath).
-
-    When you place a window in a sizer the window's initial size
-    (either set explicitly by the user or calculated internally when
-    using wxDefaultSize) is interpreted as the minimal and in many
-    cases also the initial size.  This is particularly useful in
-    connection with SetSizeHints.
-
-    Adding spacers to sizers gives more flexibility in the design of
-    dialogs.  Imagine for example a horizontal box with two buttons at
-    the bottom of a dialog: you might want to insert a space between
-    the two buttons and make that space stretchable using the
-    proportion flag and the result will be that the left button will
-    be aligned with the left side of the dialog and the right button
-    with the right side - the space in between will shrink and grow
-    with the dialog.
-
-    Several methods (Add, Insert, Prepend) take the following
-    parameters:
-
-    proportion - Used only by BoxSizer to indicate if a child of a
-    sizer can change its size in the main orientation of the BoxSizer,
-    where 0 stands for not changeable and a value of more than zero is
-    interpreted relative to the value of other children of the same
-    BoxSizer.  For example, you might have a horizontal BoxSizer with
-    three children, two of which are supposed to change their size
-    with the sizer.  Then the two stretchable windows would each get a
-    value of 1 to make them grow and shrink equally with the sizer's
-    horizontal dimension.
-
-    flag - This parameter can be used to set a number of flags which
-    can be combined using the binary OR operator |.  Two main
-    behaviours are defined using these flags.  One is the border
-    around a window: the border parameter determines the border width
-    whereas the flags given here determine where the border may be
-    (wx.TOP, wx.BOTTOM, wx.LEFT, wx.RIGHT or wx.ALL).  The other flags
-    determine the child window's behaviour if the size of the sizer
-    changes.  However this is not - in contrast to the proportion flag
-    - in the main orientation, but in the respectively other
-    orientation.  So if you created a BoxSizer with the wx.VERTICAL
-    option, these flags will be relevant if the sizer changes its
-    horizontal size.  A child may get resized to completely fill out
-    the new size (using either wx.GROW or wx.EXPAND), it may get
-    proportionally resized (wx.SHAPED), it may get centered
-    (wx.ALIGN_CENTER or wx.ALIGN_CENTRE) or it may get aligned to
-    either side (wx.ALIGN_LEFT and wx.ALIGN_TOP are set to 0 and thus
-    represent the default, wx.ALIGN_RIGHT and wx.ALIGN_BOTTOM have
-    their obvious meaning).  With proportional resize, a child may
-    also be centered in the main orientation using
-    wx.ALIGN_CENTER_VERTICAL (same as wx.ALIGN_CENTRE_VERTICAL) and
-    wx.ALIGN_CENTER_HORIZONTAL (same as wx.ALIGN_CENTRE_HORIZONTAL)
-    flags.  Finally, you can also specify wx.ADJUST_MINSIZE flag to
-    make the minimal size of the control dynamically adjust to the
-    value returned by its GetAdjustedBestSize() method - this allows,
-    for example, for correct relayouting of a static text control even
-    if its text is changed during run-time.
-
-    border - Determines the border width, if the flag parameter is set
-    to any border.  A border is not a visible element, but rather a
-    margin of empty space surrounding the item.
-
-    userData - Allows an extra object to be attached to the sizer
-    item, for use in derived classes when sizing information is more
-    complex than the option and flag parameters will allow."""
-
-    def __init__(self):
-        """Must be defined by subclasses."""
-        pass
-
-    def Add(self, item, proportion=0, flag=0, border=0,
-            userData=wx.NULL):
-        """Add item to sizer.
-
-        item - window, sizer, or spacer.  Spacer is specified with a
-        (width, height) tuple or wx.Size representing the spacer size.
-
-        Call Layout() to update the layout on-screen after adding."""
-        pass
-
-    def Clear(self, delete_windows=False):
-        """Remove all items from this sizer.
-
-        If delete_windows is True, destroy any window items."""
-        pass
-
-    def DeleteWindows(self):
-        """Destroy windows associated with this sizer."""
-        pass
-
-    def Destroy(self):
-        """Destroy the sizer."""
-        pass
-
-    def Fit(self, window):
-        """Resize window to match sizer's minimal size; return size.
-
-        This is commonly done in the constructor of the window itself."""
-        pass
-
-    def FitInside(self, window):
-        """Resize window virtual size to match sizer's minimal size.
-
-        This will not alter the on screen size of the window, but may
-        cause the addition/removal/alteration of scrollbars required
-        to view the virtual area in windows which manage it."""
-        pass
-
-    def GetChildren(self):
-        """Return list of SizerItem instances."""
-        pass
-
-    def GetMinSize(self):
-        """Return the minimal size of the sizer.
-
-        This is either the combined minimal size of all the children
-        and their borders or the minimal size set by SetMinSize,
-        whichever is larger."""
-        pass
-
-    def GetMinSizeTuple(self):
-        """Return the minimal size of the sizer as a tuple.
-
-        This is either the combined minimal size of all the children
-        and their borders or the minimal size set by SetMinSize,
-        whichever is larger."""
-        pass
-
-    def GetPosition(self):
-        """Return the current position of the sizer."""
-        pass
-
-    def GetPositionTuple(self):
-        """Return the current position of the sizer as a tuple."""
-        pass
-
-    def GetSize(self):
-        """Return the current size of the sizer."""
-        pass
-
-    def GetSizeTuple(self):
-        """Return the current size of the sizer as a tuple."""
-        pass
-
-    def Hide(self, item):
-        """Hide item (sizer or window).  To make a sizer item
-        disappear on-screen, use Hide() followed by Layout()."""
-        pass
-
-    def Insert(self, before, item, proportion=0, flag=0, border=0,
-               userData=wx.NULL):
-        """Same as Add, but inserts item into list of items (windows,
-        subsizers or spacers) owned by this sizer.
-
-        Call Layout() to update the layout on-screen after inserting."""
-        pass
-
-    def IsShown(self, item):
-        """Return True if item (sizer or window) is shown."""
-        pass
-
-    def Layout(self):
-        """Force layout of children anew.
-
-        Use after adding or removing a child (window, other sizer, or
-        spacer) from the sizer while keeping the current dimension."""
-        pass
-
-    def Prepend(self, item, proportion=0, flag=0, border=0,
-                userData=wx.NULL):
-        """Same as Add, but prepends item to beginning of list of
-        items (windows, subsizers or spacers) owned by this sizer.
-
-        Call Layout() to update the layout on-screen after prepending."""
-        pass
-
-    def Remove(self, item):
-        """Remove item from the sizer.
-
-        item - sizer, window, or index of item in the sizer, typically
-        0 for the first item.
-
-        Does not cause any layout or resizing to take place, and does
-        not delete the child itself.  Call Layout() to update the
-        layout on-screen after removing child.
-
-        Return True if child found and removed, False otherwise."""
-        pass
-
-    def SetDimension(self, x, y, width, height):
-        """Force sizer to take the given dimension and thus force
-        items owned by sizer to resize themselves according to the
-        rules defined by the parameter in the Add and Prepend methods."""
-        pass
-
-    def SetItemMinSize(self, item, width, height):
-        """Set minimal size of item.
-
-        item - sizer, window, or index of item in the sizer, typically
-        0 for the first item.
-
-        The item will be found recursively in the sizer's descendants.
-        Enables application to set size of item after initialization."""
-        pass
-
-    def SetMinSize(self, size):
-        """Set minimal size.
-
-        Normally, sizer will calculate minimal size based on how much
-        space its children need.  After calling this method,
-        GetMinSize will return the minimal size as requested by its
-        children or the minimal size set here, whichever is larger."""
-        pass
-
-    def SetSizeHints(self, window):
-        """Set (and Fit) minimal size of window to match sizer's
-        minimal size.  Commonly called in the window's init."""
-        pass
-
-    def SetVirtualSizeHints(self, window):
-        """Set minimal size of window virtual area to match sizer's
-        minimal size.  For windows with managed scrollbars this will
-        set them appropriately."""
-        pass
-
-    def Show(self, item, show=True):
-        """Show or hide item (sizer or window).  To make item
-        disappear or reappear on-screen, use Show() followed by
-        Layout()."""
-        pass
-
-    def ShowItems(self, show):
-        """Recursively call Show() on all sizer items."""
-        pass
-
-
-class PySizer(Sizer):
-    """If you wish to create a custom sizer class you should derive
-    the class from PySizer in order to get Python-aware capabilities
-    for the various virtual methods."""
-
-    def __init__(self):
-        """Create a PySizer instance.  Override in subclass."""
-        pass
-
-
-class BoxSizer(Sizer):
-    """A box sizer is used to lay out a rather simple geometry,
-    typically a row or column or several hierarchies of either."""
-
-    def __init__(self, orient=wx.HORIZONTAL):
-        """Create BoxSizer instance.
-
-        orient is either wx.VERTICAL or wx.HORIZONTAL"""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetOrientation(self):
-        """Return orientation: wx.VERTICAL or wx.HORIZONTAL."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-    def SetOrientation(self, orient):
-        """Set orientation to either wx.VERTICAL or wx.HORIZONTAL."""
-        pass
-
-
-class StaticBoxSizer(BoxSizer):
-    """Like BoxSizer, but adds a static box around the sizer.  Note
-    that the static box has to be created separately."""
-
-    def __init__(self, box, orient=wx.HORIZONTAL):
-        """Create StaticBoxSizer instance.
-
-        box - instance of wx.StaticBox
-
-        orient - either wx.VERTICAL or wx.HORIZONTAL"""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetStaticBox(self):
-        """Return the static box associated with the sizer."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-
-class GridSizer(Sizer):
-    """A grid sizer lays out its children in a two-dimensional table
-    where all cells have the same size: the width of each cell is the
-    width of the widest child, the height of each cell is the height
-    of the tallest child.  See also the FlexGridSizer."""
-
-    def __init__(self, rows=1, cols=0, vgap=0, hgap=0):
-        """Create a GridSizer instance.
-
-        rows and cols - the number of rows and columns in the grid; if
-        either is zero, it will be calculated as the number of
-        children in the sizer, allowing the sizer grow dynamically.
-
-        vgap and hgap - extra space between all cells, in pixels."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetCols(self):
-        """Return the number of columns in the grid."""
-        pass
-
-    def GetHGap(self):
-        """Return the horizontal gap (in pixels) between cells."""
-        pass
-
-    def GetRows(self):
-        """Return the number of rows in the grid."""
-        pass
-
-    def GetVGap(self):
-        """Return the vertical gap (in pixels) between cells."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-    def SetCols(self, cols):
-        """Set the number of columns in the grid."""
-        pass
-
-    def SetHGap(self, gap):
-        """Set the horizontal gap (in pixels) between cells."""
-        pass
-
-    def SetRows(self, rows):
-        """Sets the number of rows in the grid."""
-        pass
-
-    def SetVGap(self, gap):
-        """Set the vertical gap (in pixels) between cells."""
-        pass
-
-
-class FlexGridSizer(GridSizer):
-    """A flex grid sizer lays out its children in a two-dimensional
-    table where all cells in one row have the same height and all
-    cells in one column have the same width, but all cells are not
-    necessarily the same height and width, as in the GridSizer."""
-
-    def __init__(self, rows=1, cols=0, vgap=0, hgap=0):
-        """Create a GridSizer instance.
-
-        rows and cols - the number of rows and columns in the grid; if
-        either is zero, it will be calculated as the number of
-        children in the sizer, allowing the sizer grow dynamically.
-
-        vgap and hgap - extra space between all cells, in pixels."""
-        pass
-
-    def AddGrowableCol(self, idx):
-        """Specify that column idx (starting from zero) should expand
-        if there is extra space available to the sizer."""
-        pass
-
-    def AddGrowableRow(self, idx):
-        """Specify that row idx (starting from zero) should expand if
-        there is extra space available to the sizer."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-    def RemoveGrowableCol(self, idx):
-        """Specify that column idx is no longer growable."""
-        pass
-
-    def RemoveGrowableRow(self, idx):
-        """Specify that row idx is no longer growable."""
-        pass
-
-
-class NotebookSizer(Sizer):
-    """NotebookSizer works with a notebook to determine the size of
-    the biggest page and report an adjusted minimal size to a more
-    toplevel sizer.  Do not add children to a NotebookSizer."""
-
-    def __init__(self, nb):
-        """Create a NotebookSizer instance for notebook."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetNotebook(self):
-        """Return the notebook associated with the sizer."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate size.  Do not call directly."""
-        pass
-
-
-class SizerItem(Object):
-    """SizerItem class.  Wrapper for items managed by a sizer."""
-
-    def __init__(self, this):
-        """Create a SizerItem instance.  You don't normally create one
-        directly."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def DeleteWindows(self):
-        """Recursively destroy windows associated with this SizerItem."""
-        pass
-
-    def GetBorder(self):
-        """Return border width."""
-        pass
-
-    def GetFlag(self):
-        """Return flag value."""
-        pass
-
-    def GetOption(self):
-        """Return option value."""
-        pass
-
-    def GetPosition(self):
-        """Return wx.Point instance representing position relative to
-        the client area."""
-        pass
-
-    def GetRatio(self):
-        """Return a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def GetSize(self):
-        """Return wx.Size instance with size."""
-        pass
-
-    def GetSizer(self):
-        """If IsSizer() return the sizer; otherwise return None."""
-        pass
-
-    def GetUserData(self):
-        """Return a wx.PyUserData object."""
-        pass
-
-    def GetWindow(self):
-        """If IsWindow() return the window; otherwise return None."""
-        pass
-
-    def IsShown(self):
-        """Return True if item is shown."""
-        pass
-
-    def IsSizer(self):
-        """Return True if SizerItem represents a sizer."""
-        pass
-
-    def IsSpacer(self):
-        """Return True if SizerItem represents a spacer."""
-        pass
-
-    def IsWindow(self):
-        """Return True if SizerItem represents a window."""
-        pass
-
-    def SetBorder(self, border):
-        """Set border width for item."""
-        pass
-
-    def SetDimension(self, pos, size):
-        """Set position and size for item."""
-        pass
-
-    def SetFlag(self, flag):
-        """Set flag for item."""
-        pass
-
-    def SetInitSize(self, x, y):
-        """Set initial size of item."""
-        pass
-
-    def SetOption(self, option):
-        """Set option for item."""
-        pass
-
-    def SetRatio(self, ratio):
-        """Set a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def SetRatioSize(self, size):
-        """Set a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def SetRatioWH(self, width, height):
-        """Set a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def SetSizer(self, sizer):
-        """Set sizer associated with SizerItem."""
-        pass
-
-    def SetWindow(self, window):
-        """Set window associated with SizerItem."""
-        pass
-
-    def Show(self, show):
-        """Is show is True, show item, otherwise hide item."""
-        pass

wxPython/wxPython/py/wxd/Streams.py

@@ -1,96 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class InputStream:
-    """"""
-
-    def CanRead(self):
-        """"""
-        pass
-
-    def Eof(self):
-        """"""
-        pass
-
-    def GetC(self):
-        """"""
-        pass
-
-    def LastRead(self):
-        """"""
-        pass
-
-    def Peek(self):
-        """"""
-        pass
-
-    def SeekI(self):
-        """"""
-        pass
-
-    def TellI(self):
-        """"""
-        pass
-
-    def Ungetch(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def close(self):
-        """"""
-        pass
-
-    def eof(self):
-        """"""
-        pass
-
-    def flush(self):
-        """"""
-        pass
-
-    def read(self):
-        """"""
-        pass
-
-    def readline(self):
-        """"""
-        pass
-
-    def readlines(self):
-        """"""
-        pass
-
-    def seek(self):
-        """"""
-        pass
-
-    def tell(self):
-        """"""
-        pass
-
-
-class OutputStream:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def write(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/StyledTextConstants.py

@@ -1,643 +0,0 @@
-"""wxStyledTextControl constants for documentation.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-from wxPython import wx
-from wxPython import stc
-
-
-"""
->>> from wxPython import stc_c
->>> def gen_constants():
-...     print '# Begin generated constants.'
-...     for item in dir(stc_c):  # dir returns a sorted list.
-...         if not callable(stc_c.__dict__[item]) \
-...         and not item.startswith('__'):
-...             print item, '=', 'stc.' + item, ' #', \
-...                   repr(stc_c.__dict__[item])
-...     print '# End generated constants.'
-
-"""
-
-# Begin generated constants.
-STC_USE_DND = stc.STC_USE_DND  # 1
-wxEVT_STC_CHANGE = stc.wxEVT_STC_CHANGE  # 10206
-wxEVT_STC_CHARADDED = stc.wxEVT_STC_CHARADDED  # 10208
-wxEVT_STC_DOUBLECLICK = stc.wxEVT_STC_DOUBLECLICK  # 10213
-wxEVT_STC_DO_DROP = stc.wxEVT_STC_DO_DROP  # 10227
-wxEVT_STC_DRAG_OVER = stc.wxEVT_STC_DRAG_OVER  # 10226
-wxEVT_STC_DWELLEND = stc.wxEVT_STC_DWELLEND  # 10224
-wxEVT_STC_DWELLSTART = stc.wxEVT_STC_DWELLSTART  # 10223
-wxEVT_STC_KEY = stc.wxEVT_STC_KEY  # 10212
-wxEVT_STC_MACRORECORD = stc.wxEVT_STC_MACRORECORD  # 10216
-wxEVT_STC_MARGINCLICK = stc.wxEVT_STC_MARGINCLICK  # 10217
-wxEVT_STC_MODIFIED = stc.wxEVT_STC_MODIFIED  # 10215
-wxEVT_STC_NEEDSHOWN = stc.wxEVT_STC_NEEDSHOWN  # 10218
-wxEVT_STC_PAINTED = stc.wxEVT_STC_PAINTED  # 10220
-wxEVT_STC_POSCHANGED = stc.wxEVT_STC_POSCHANGED  # 10219
-wxEVT_STC_ROMODIFYATTEMPT = stc.wxEVT_STC_ROMODIFYATTEMPT  # 10211
-wxEVT_STC_SAVEPOINTLEFT = stc.wxEVT_STC_SAVEPOINTLEFT  # 10210
-wxEVT_STC_SAVEPOINTREACHED = stc.wxEVT_STC_SAVEPOINTREACHED  # 10209
-wxEVT_STC_START_DRAG = stc.wxEVT_STC_START_DRAG  # 10225
-wxEVT_STC_STYLENEEDED = stc.wxEVT_STC_STYLENEEDED  # 10207
-wxEVT_STC_UPDATEUI = stc.wxEVT_STC_UPDATEUI  # 10214
-wxEVT_STC_URIDROPPED = stc.wxEVT_STC_URIDROPPED  # 10222
-wxEVT_STC_USERLISTSELECTION = stc.wxEVT_STC_USERLISTSELECTION  # 10221
-wxEVT_STC_ZOOM = stc.wxEVT_STC_ZOOM  # 10228
-wxSTC_ADA_CHARACTER = stc.wxSTC_ADA_CHARACTER  # 5
-wxSTC_ADA_COMMENT = stc.wxSTC_ADA_COMMENT  # 1
-wxSTC_ADA_DEFAULT = stc.wxSTC_ADA_DEFAULT  # 0
-wxSTC_ADA_IDENTIFIER = stc.wxSTC_ADA_IDENTIFIER  # 7
-wxSTC_ADA_NUMBER = stc.wxSTC_ADA_NUMBER  # 2
-wxSTC_ADA_OPERATOR = stc.wxSTC_ADA_OPERATOR  # 6
-wxSTC_ADA_STRING = stc.wxSTC_ADA_STRING  # 4
-wxSTC_ADA_STRINGEOL = stc.wxSTC_ADA_STRINGEOL  # 8
-wxSTC_ADA_WORD = stc.wxSTC_ADA_WORD  # 3
-wxSTC_AVE_COMMENT = stc.wxSTC_AVE_COMMENT  # 1
-wxSTC_AVE_DEFAULT = stc.wxSTC_AVE_DEFAULT  # 0
-wxSTC_AVE_ENUM = stc.wxSTC_AVE_ENUM  # 7
-wxSTC_AVE_IDENTIFIER = stc.wxSTC_AVE_IDENTIFIER  # 9
-wxSTC_AVE_KEYWORD = stc.wxSTC_AVE_KEYWORD  # 4
-wxSTC_AVE_NUMBER = stc.wxSTC_AVE_NUMBER  # 2
-wxSTC_AVE_OPERATOR = stc.wxSTC_AVE_OPERATOR  # 10
-wxSTC_AVE_STATEMENT = stc.wxSTC_AVE_STATEMENT  # 5
-wxSTC_AVE_STRING = stc.wxSTC_AVE_STRING  # 6
-wxSTC_AVE_STRINGEOL = stc.wxSTC_AVE_STRINGEOL  # 8
-wxSTC_AVE_WORD = stc.wxSTC_AVE_WORD  # 3
-wxSTC_BAAN_COMMENT = stc.wxSTC_BAAN_COMMENT  # 1
-wxSTC_BAAN_COMMENTDOC = stc.wxSTC_BAAN_COMMENTDOC  # 2
-wxSTC_BAAN_DEFAULT = stc.wxSTC_BAAN_DEFAULT  # 0
-wxSTC_BAAN_IDENTIFIER = stc.wxSTC_BAAN_IDENTIFIER  # 8
-wxSTC_BAAN_NUMBER = stc.wxSTC_BAAN_NUMBER  # 3
-wxSTC_BAAN_OPERATOR = stc.wxSTC_BAAN_OPERATOR  # 7
-wxSTC_BAAN_PREPROCESSOR = stc.wxSTC_BAAN_PREPROCESSOR  # 6
-wxSTC_BAAN_STRING = stc.wxSTC_BAAN_STRING  # 5
-wxSTC_BAAN_STRINGEOL = stc.wxSTC_BAAN_STRINGEOL  # 9
-wxSTC_BAAN_WORD = stc.wxSTC_BAAN_WORD  # 4
-wxSTC_BAAN_WORD2 = stc.wxSTC_BAAN_WORD2  # 10
-wxSTC_BAT_COMMAND = stc.wxSTC_BAT_COMMAND  # 5
-wxSTC_BAT_COMMENT = stc.wxSTC_BAT_COMMENT  # 1
-wxSTC_BAT_DEFAULT = stc.wxSTC_BAT_DEFAULT  # 0
-wxSTC_BAT_HIDE = stc.wxSTC_BAT_HIDE  # 4
-wxSTC_BAT_IDENTIFIER = stc.wxSTC_BAT_IDENTIFIER  # 6
-wxSTC_BAT_LABEL = stc.wxSTC_BAT_LABEL  # 3
-wxSTC_BAT_OPERATOR = stc.wxSTC_BAT_OPERATOR  # 7
-wxSTC_BAT_WORD = stc.wxSTC_BAT_WORD  # 2
-wxSTC_B_COMMENT = stc.wxSTC_B_COMMENT  # 1
-wxSTC_B_DATE = stc.wxSTC_B_DATE  # 8
-wxSTC_B_DEFAULT = stc.wxSTC_B_DEFAULT  # 0
-wxSTC_B_IDENTIFIER = stc.wxSTC_B_IDENTIFIER  # 7
-wxSTC_B_KEYWORD = stc.wxSTC_B_KEYWORD  # 3
-wxSTC_B_NUMBER = stc.wxSTC_B_NUMBER  # 2
-wxSTC_B_OPERATOR = stc.wxSTC_B_OPERATOR  # 6
-wxSTC_B_PREPROCESSOR = stc.wxSTC_B_PREPROCESSOR  # 5
-wxSTC_B_STRING = stc.wxSTC_B_STRING  # 4
-wxSTC_CACHE_CARET = stc.wxSTC_CACHE_CARET  # 1
-wxSTC_CACHE_DOCUMENT = stc.wxSTC_CACHE_DOCUMENT  # 3
-wxSTC_CACHE_NONE = stc.wxSTC_CACHE_NONE  # 0
-wxSTC_CACHE_PAGE = stc.wxSTC_CACHE_PAGE  # 2
-wxSTC_CARET_EVEN = stc.wxSTC_CARET_EVEN  # 8
-wxSTC_CARET_JUMPS = stc.wxSTC_CARET_JUMPS  # 16
-wxSTC_CARET_SLOP = stc.wxSTC_CARET_SLOP  # 1
-wxSTC_CARET_STRICT = stc.wxSTC_CARET_STRICT  # 4
-wxSTC_CASE_LOWER = stc.wxSTC_CASE_LOWER  # 2
-wxSTC_CASE_MIXED = stc.wxSTC_CASE_MIXED  # 0
-wxSTC_CASE_UPPER = stc.wxSTC_CASE_UPPER  # 1
-wxSTC_CHARSET_ANSI = stc.wxSTC_CHARSET_ANSI  # 0
-wxSTC_CHARSET_ARABIC = stc.wxSTC_CHARSET_ARABIC  # 178
-wxSTC_CHARSET_BALTIC = stc.wxSTC_CHARSET_BALTIC  # 186
-wxSTC_CHARSET_CHINESEBIG5 = stc.wxSTC_CHARSET_CHINESEBIG5  # 136
-wxSTC_CHARSET_DEFAULT = stc.wxSTC_CHARSET_DEFAULT  # 1
-wxSTC_CHARSET_EASTEUROPE = stc.wxSTC_CHARSET_EASTEUROPE  # 238
-wxSTC_CHARSET_GB2312 = stc.wxSTC_CHARSET_GB2312  # 134
-wxSTC_CHARSET_GREEK = stc.wxSTC_CHARSET_GREEK  # 161
-wxSTC_CHARSET_HANGUL = stc.wxSTC_CHARSET_HANGUL  # 129
-wxSTC_CHARSET_HEBREW = stc.wxSTC_CHARSET_HEBREW  # 177
-wxSTC_CHARSET_JOHAB = stc.wxSTC_CHARSET_JOHAB  # 130
-wxSTC_CHARSET_MAC = stc.wxSTC_CHARSET_MAC  # 77
-wxSTC_CHARSET_OEM = stc.wxSTC_CHARSET_OEM  # 255
-wxSTC_CHARSET_RUSSIAN = stc.wxSTC_CHARSET_RUSSIAN  # 204
-wxSTC_CHARSET_SHIFTJIS = stc.wxSTC_CHARSET_SHIFTJIS  # 128
-wxSTC_CHARSET_SYMBOL = stc.wxSTC_CHARSET_SYMBOL  # 2
-wxSTC_CHARSET_THAI = stc.wxSTC_CHARSET_THAI  # 222
-wxSTC_CHARSET_TURKISH = stc.wxSTC_CHARSET_TURKISH  # 162
-wxSTC_CHARSET_VIETNAMESE = stc.wxSTC_CHARSET_VIETNAMESE  # 163
-wxSTC_CMD_BACKTAB = stc.wxSTC_CMD_BACKTAB  # 2328
-wxSTC_CMD_CANCEL = stc.wxSTC_CMD_CANCEL  # 2325
-wxSTC_CMD_CHARLEFT = stc.wxSTC_CMD_CHARLEFT  # 2304
-wxSTC_CMD_CHARLEFTEXTEND = stc.wxSTC_CMD_CHARLEFTEXTEND  # 2305
-wxSTC_CMD_CHARRIGHT = stc.wxSTC_CMD_CHARRIGHT  # 2306
-wxSTC_CMD_CHARRIGHTEXTEND = stc.wxSTC_CMD_CHARRIGHTEXTEND  # 2307
-wxSTC_CMD_CLEAR = stc.wxSTC_CMD_CLEAR  # 2180
-wxSTC_CMD_COPY = stc.wxSTC_CMD_COPY  # 2178
-wxSTC_CMD_CUT = stc.wxSTC_CMD_CUT  # 2177
-wxSTC_CMD_DELETEBACK = stc.wxSTC_CMD_DELETEBACK  # 2326
-wxSTC_CMD_DELETEBACKNOTLINE = stc.wxSTC_CMD_DELETEBACKNOTLINE  # 2344
-wxSTC_CMD_DELLINELEFT = stc.wxSTC_CMD_DELLINELEFT  # 2395
-wxSTC_CMD_DELLINERIGHT = stc.wxSTC_CMD_DELLINERIGHT  # 2396
-wxSTC_CMD_DELWORDLEFT = stc.wxSTC_CMD_DELWORDLEFT  # 2335
-wxSTC_CMD_DELWORDRIGHT = stc.wxSTC_CMD_DELWORDRIGHT  # 2336
-wxSTC_CMD_DOCUMENTEND = stc.wxSTC_CMD_DOCUMENTEND  # 2318
-wxSTC_CMD_DOCUMENTENDEXTEND = stc.wxSTC_CMD_DOCUMENTENDEXTEND  # 2319
-wxSTC_CMD_DOCUMENTSTART = stc.wxSTC_CMD_DOCUMENTSTART  # 2316
-wxSTC_CMD_DOCUMENTSTARTEXTEND = stc.wxSTC_CMD_DOCUMENTSTARTEXTEND  # 2317
-wxSTC_CMD_EDITTOGGLEOVERTYPE = stc.wxSTC_CMD_EDITTOGGLEOVERTYPE  # 2324
-wxSTC_CMD_FORMFEED = stc.wxSTC_CMD_FORMFEED  # 2330
-wxSTC_CMD_HOME = stc.wxSTC_CMD_HOME  # 2312
-wxSTC_CMD_HOMEDISPLAY = stc.wxSTC_CMD_HOMEDISPLAY  # 2345
-wxSTC_CMD_HOMEDISPLAYEXTEND = stc.wxSTC_CMD_HOMEDISPLAYEXTEND  # 2346
-wxSTC_CMD_HOMEEXTEND = stc.wxSTC_CMD_HOMEEXTEND  # 2313
-wxSTC_CMD_LINECUT = stc.wxSTC_CMD_LINECUT  # 2337
-wxSTC_CMD_LINEDELETE = stc.wxSTC_CMD_LINEDELETE  # 2338
-wxSTC_CMD_LINEDOWN = stc.wxSTC_CMD_LINEDOWN  # 2300
-wxSTC_CMD_LINEDOWNEXTEND = stc.wxSTC_CMD_LINEDOWNEXTEND  # 2301
-wxSTC_CMD_LINEEND = stc.wxSTC_CMD_LINEEND  # 2314
-wxSTC_CMD_LINEENDDISPLAY = stc.wxSTC_CMD_LINEENDDISPLAY  # 2347
-wxSTC_CMD_LINEENDDISPLAYEXTEND = stc.wxSTC_CMD_LINEENDDISPLAYEXTEND  # 2348
-wxSTC_CMD_LINEENDEXTEND = stc.wxSTC_CMD_LINEENDEXTEND  # 2315
-wxSTC_CMD_LINESCROLLDOWN = stc.wxSTC_CMD_LINESCROLLDOWN  # 2342
-wxSTC_CMD_LINESCROLLUP = stc.wxSTC_CMD_LINESCROLLUP  # 2343
-wxSTC_CMD_LINETRANSPOSE = stc.wxSTC_CMD_LINETRANSPOSE  # 2339
-wxSTC_CMD_LINEUP = stc.wxSTC_CMD_LINEUP  # 2302
-wxSTC_CMD_LINEUPEXTEND = stc.wxSTC_CMD_LINEUPEXTEND  # 2303
-wxSTC_CMD_LOWERCASE = stc.wxSTC_CMD_LOWERCASE  # 2340
-wxSTC_CMD_NEWLINE = stc.wxSTC_CMD_NEWLINE  # 2329
-wxSTC_CMD_PAGEDOWN = stc.wxSTC_CMD_PAGEDOWN  # 2322
-wxSTC_CMD_PAGEDOWNEXTEND = stc.wxSTC_CMD_PAGEDOWNEXTEND  # 2323
-wxSTC_CMD_PAGEUP = stc.wxSTC_CMD_PAGEUP  # 2320
-wxSTC_CMD_PAGEUPEXTEND = stc.wxSTC_CMD_PAGEUPEXTEND  # 2321
-wxSTC_CMD_PASTE = stc.wxSTC_CMD_PASTE  # 2179
-wxSTC_CMD_REDO = stc.wxSTC_CMD_REDO  # 2011
-wxSTC_CMD_SELECTALL = stc.wxSTC_CMD_SELECTALL  # 2013
-wxSTC_CMD_TAB = stc.wxSTC_CMD_TAB  # 2327
-wxSTC_CMD_UNDO = stc.wxSTC_CMD_UNDO  # 2176
-wxSTC_CMD_UPPERCASE = stc.wxSTC_CMD_UPPERCASE  # 2341
-wxSTC_CMD_VCHOME = stc.wxSTC_CMD_VCHOME  # 2331
-wxSTC_CMD_VCHOMEEXTEND = stc.wxSTC_CMD_VCHOMEEXTEND  # 2332
-wxSTC_CMD_WORDLEFT = stc.wxSTC_CMD_WORDLEFT  # 2308
-wxSTC_CMD_WORDLEFTEXTEND = stc.wxSTC_CMD_WORDLEFTEXTEND  # 2309
-wxSTC_CMD_WORDPARTLEFT = stc.wxSTC_CMD_WORDPARTLEFT  # 2390
-wxSTC_CMD_WORDPARTLEFTEXTEND = stc.wxSTC_CMD_WORDPARTLEFTEXTEND  # 2391
-wxSTC_CMD_WORDPARTRIGHT = stc.wxSTC_CMD_WORDPARTRIGHT  # 2392
-wxSTC_CMD_WORDPARTRIGHTEXTEND = stc.wxSTC_CMD_WORDPARTRIGHTEXTEND  # 2393
-wxSTC_CMD_WORDRIGHT = stc.wxSTC_CMD_WORDRIGHT  # 2310
-wxSTC_CMD_WORDRIGHTEXTEND = stc.wxSTC_CMD_WORDRIGHTEXTEND  # 2311
-wxSTC_CMD_ZOOMIN = stc.wxSTC_CMD_ZOOMIN  # 2333
-wxSTC_CMD_ZOOMOUT = stc.wxSTC_CMD_ZOOMOUT  # 2334
-wxSTC_CONF_COMMENT = stc.wxSTC_CONF_COMMENT  # 1
-wxSTC_CONF_DEFAULT = stc.wxSTC_CONF_DEFAULT  # 0
-wxSTC_CONF_DIRECTIVE = stc.wxSTC_CONF_DIRECTIVE  # 9
-wxSTC_CONF_EXTENSION = stc.wxSTC_CONF_EXTENSION  # 4
-wxSTC_CONF_IDENTIFIER = stc.wxSTC_CONF_IDENTIFIER  # 3
-wxSTC_CONF_IP = stc.wxSTC_CONF_IP  # 8
-wxSTC_CONF_NUMBER = stc.wxSTC_CONF_NUMBER  # 2
-wxSTC_CONF_OPERATOR = stc.wxSTC_CONF_OPERATOR  # 7
-wxSTC_CONF_PARAMETER = stc.wxSTC_CONF_PARAMETER  # 5
-wxSTC_CONF_STRING = stc.wxSTC_CONF_STRING  # 6
-wxSTC_CP_UTF8 = stc.wxSTC_CP_UTF8  # 65001
-wxSTC_CURSORNORMAL = stc.wxSTC_CURSORNORMAL  # -1
-wxSTC_CURSORWAIT = stc.wxSTC_CURSORWAIT  # 3
-wxSTC_C_CHARACTER = stc.wxSTC_C_CHARACTER  # 7
-wxSTC_C_COMMENT = stc.wxSTC_C_COMMENT  # 1
-wxSTC_C_COMMENTDOC = stc.wxSTC_C_COMMENTDOC  # 3
-wxSTC_C_COMMENTDOCKEYWORD = stc.wxSTC_C_COMMENTDOCKEYWORD  # 17
-wxSTC_C_COMMENTDOCKEYWORDERROR = stc.wxSTC_C_COMMENTDOCKEYWORDERROR  # 18
-wxSTC_C_COMMENTLINE = stc.wxSTC_C_COMMENTLINE  # 2
-wxSTC_C_COMMENTLINEDOC = stc.wxSTC_C_COMMENTLINEDOC  # 15
-wxSTC_C_DEFAULT = stc.wxSTC_C_DEFAULT  # 0
-wxSTC_C_IDENTIFIER = stc.wxSTC_C_IDENTIFIER  # 11
-wxSTC_C_NUMBER = stc.wxSTC_C_NUMBER  # 4
-wxSTC_C_OPERATOR = stc.wxSTC_C_OPERATOR  # 10
-wxSTC_C_PREPROCESSOR = stc.wxSTC_C_PREPROCESSOR  # 9
-wxSTC_C_REGEX = stc.wxSTC_C_REGEX  # 14
-wxSTC_C_STRING = stc.wxSTC_C_STRING  # 6
-wxSTC_C_STRINGEOL = stc.wxSTC_C_STRINGEOL  # 12
-wxSTC_C_UUID = stc.wxSTC_C_UUID  # 8
-wxSTC_C_VERBATIM = stc.wxSTC_C_VERBATIM  # 13
-wxSTC_C_WORD = stc.wxSTC_C_WORD  # 5
-wxSTC_C_WORD2 = stc.wxSTC_C_WORD2  # 16
-wxSTC_DIFF_ADDED = stc.wxSTC_DIFF_ADDED  # 6
-wxSTC_DIFF_COMMAND = stc.wxSTC_DIFF_COMMAND  # 2
-wxSTC_DIFF_COMMENT = stc.wxSTC_DIFF_COMMENT  # 1
-wxSTC_DIFF_DEFAULT = stc.wxSTC_DIFF_DEFAULT  # 0
-wxSTC_DIFF_DELETED = stc.wxSTC_DIFF_DELETED  # 5
-wxSTC_DIFF_HEADER = stc.wxSTC_DIFF_HEADER  # 3
-wxSTC_DIFF_POSITION = stc.wxSTC_DIFF_POSITION  # 4
-wxSTC_EDGE_BACKGROUND = stc.wxSTC_EDGE_BACKGROUND  # 2
-wxSTC_EDGE_LINE = stc.wxSTC_EDGE_LINE  # 1
-wxSTC_EDGE_NONE = stc.wxSTC_EDGE_NONE  # 0
-wxSTC_EIFFEL_CHARACTER = stc.wxSTC_EIFFEL_CHARACTER  # 5
-wxSTC_EIFFEL_COMMENTLINE = stc.wxSTC_EIFFEL_COMMENTLINE  # 1
-wxSTC_EIFFEL_DEFAULT = stc.wxSTC_EIFFEL_DEFAULT  # 0
-wxSTC_EIFFEL_IDENTIFIER = stc.wxSTC_EIFFEL_IDENTIFIER  # 7
-wxSTC_EIFFEL_NUMBER = stc.wxSTC_EIFFEL_NUMBER  # 2
-wxSTC_EIFFEL_OPERATOR = stc.wxSTC_EIFFEL_OPERATOR  # 6
-wxSTC_EIFFEL_STRING = stc.wxSTC_EIFFEL_STRING  # 4
-wxSTC_EIFFEL_STRINGEOL = stc.wxSTC_EIFFEL_STRINGEOL  # 8
-wxSTC_EIFFEL_WORD = stc.wxSTC_EIFFEL_WORD  # 3
-wxSTC_EOL_CR = stc.wxSTC_EOL_CR  # 1
-wxSTC_EOL_CRLF = stc.wxSTC_EOL_CRLF  # 0
-wxSTC_EOL_LF = stc.wxSTC_EOL_LF  # 2
-wxSTC_ERR_BORLAND = stc.wxSTC_ERR_BORLAND  # 5
-wxSTC_ERR_CMD = stc.wxSTC_ERR_CMD  # 4
-wxSTC_ERR_CTAG = stc.wxSTC_ERR_CTAG  # 9
-wxSTC_ERR_DEFAULT = stc.wxSTC_ERR_DEFAULT  # 0
-wxSTC_ERR_DIFF_ADDITION = stc.wxSTC_ERR_DIFF_ADDITION  # 11
-wxSTC_ERR_DIFF_CHANGED = stc.wxSTC_ERR_DIFF_CHANGED  # 10
-wxSTC_ERR_DIFF_DELETION = stc.wxSTC_ERR_DIFF_DELETION  # 12
-wxSTC_ERR_DIFF_MESSAGE = stc.wxSTC_ERR_DIFF_MESSAGE  # 13
-wxSTC_ERR_GCC = stc.wxSTC_ERR_GCC  # 2
-wxSTC_ERR_LUA = stc.wxSTC_ERR_LUA  # 8
-wxSTC_ERR_MS = stc.wxSTC_ERR_MS  # 3
-wxSTC_ERR_NET = stc.wxSTC_ERR_NET  # 7
-wxSTC_ERR_PERL = stc.wxSTC_ERR_PERL  # 6
-wxSTC_ERR_PYTHON = stc.wxSTC_ERR_PYTHON  # 1
-wxSTC_FIND_MATCHCASE = stc.wxSTC_FIND_MATCHCASE  # 4
-wxSTC_FIND_REGEXP = stc.wxSTC_FIND_REGEXP  # 2097152
-wxSTC_FIND_WHOLEWORD = stc.wxSTC_FIND_WHOLEWORD  # 2
-wxSTC_FIND_WORDSTART = stc.wxSTC_FIND_WORDSTART  # 1048576
-wxSTC_FOLDLEVELBASE = stc.wxSTC_FOLDLEVELBASE  # 1024
-wxSTC_FOLDLEVELHEADERFLAG = stc.wxSTC_FOLDLEVELHEADERFLAG  # 8192
-wxSTC_FOLDLEVELNUMBERMASK = stc.wxSTC_FOLDLEVELNUMBERMASK  # 4095
-wxSTC_FOLDLEVELWHITEFLAG = stc.wxSTC_FOLDLEVELWHITEFLAG  # 4096
-wxSTC_HBA_COMMENTLINE = stc.wxSTC_HBA_COMMENTLINE  # 82
-wxSTC_HBA_DEFAULT = stc.wxSTC_HBA_DEFAULT  # 81
-wxSTC_HBA_IDENTIFIER = stc.wxSTC_HBA_IDENTIFIER  # 86
-wxSTC_HBA_NUMBER = stc.wxSTC_HBA_NUMBER  # 83
-wxSTC_HBA_START = stc.wxSTC_HBA_START  # 80
-wxSTC_HBA_STRING = stc.wxSTC_HBA_STRING  # 85
-wxSTC_HBA_STRINGEOL = stc.wxSTC_HBA_STRINGEOL  # 87
-wxSTC_HBA_WORD = stc.wxSTC_HBA_WORD  # 84
-wxSTC_HB_COMMENTLINE = stc.wxSTC_HB_COMMENTLINE  # 72
-wxSTC_HB_DEFAULT = stc.wxSTC_HB_DEFAULT  # 71
-wxSTC_HB_IDENTIFIER = stc.wxSTC_HB_IDENTIFIER  # 76
-wxSTC_HB_NUMBER = stc.wxSTC_HB_NUMBER  # 73
-wxSTC_HB_START = stc.wxSTC_HB_START  # 70
-wxSTC_HB_STRING = stc.wxSTC_HB_STRING  # 75
-wxSTC_HB_STRINGEOL = stc.wxSTC_HB_STRINGEOL  # 77
-wxSTC_HB_WORD = stc.wxSTC_HB_WORD  # 74
-wxSTC_HJA_COMMENT = stc.wxSTC_HJA_COMMENT  # 57
-wxSTC_HJA_COMMENTDOC = stc.wxSTC_HJA_COMMENTDOC  # 59
-wxSTC_HJA_COMMENTLINE = stc.wxSTC_HJA_COMMENTLINE  # 58
-wxSTC_HJA_DEFAULT = stc.wxSTC_HJA_DEFAULT  # 56
-wxSTC_HJA_DOUBLESTRING = stc.wxSTC_HJA_DOUBLESTRING  # 63
-wxSTC_HJA_KEYWORD = stc.wxSTC_HJA_KEYWORD  # 62
-wxSTC_HJA_NUMBER = stc.wxSTC_HJA_NUMBER  # 60
-wxSTC_HJA_REGEX = stc.wxSTC_HJA_REGEX  # 67
-wxSTC_HJA_SINGLESTRING = stc.wxSTC_HJA_SINGLESTRING  # 64
-wxSTC_HJA_START = stc.wxSTC_HJA_START  # 55
-wxSTC_HJA_STRINGEOL = stc.wxSTC_HJA_STRINGEOL  # 66
-wxSTC_HJA_SYMBOLS = stc.wxSTC_HJA_SYMBOLS  # 65
-wxSTC_HJA_WORD = stc.wxSTC_HJA_WORD  # 61
-wxSTC_HJ_COMMENT = stc.wxSTC_HJ_COMMENT  # 42
-wxSTC_HJ_COMMENTDOC = stc.wxSTC_HJ_COMMENTDOC  # 44
-wxSTC_HJ_COMMENTLINE = stc.wxSTC_HJ_COMMENTLINE  # 43
-wxSTC_HJ_DEFAULT = stc.wxSTC_HJ_DEFAULT  # 41
-wxSTC_HJ_DOUBLESTRING = stc.wxSTC_HJ_DOUBLESTRING  # 48
-wxSTC_HJ_KEYWORD = stc.wxSTC_HJ_KEYWORD  # 47
-wxSTC_HJ_NUMBER = stc.wxSTC_HJ_NUMBER  # 45
-wxSTC_HJ_REGEX = stc.wxSTC_HJ_REGEX  # 52
-wxSTC_HJ_SINGLESTRING = stc.wxSTC_HJ_SINGLESTRING  # 49
-wxSTC_HJ_START = stc.wxSTC_HJ_START  # 40
-wxSTC_HJ_STRINGEOL = stc.wxSTC_HJ_STRINGEOL  # 51
-wxSTC_HJ_SYMBOLS = stc.wxSTC_HJ_SYMBOLS  # 50
-wxSTC_HJ_WORD = stc.wxSTC_HJ_WORD  # 46
-wxSTC_HPA_CHARACTER = stc.wxSTC_HPA_CHARACTER  # 110
-wxSTC_HPA_CLASSNAME = stc.wxSTC_HPA_CLASSNAME  # 114
-wxSTC_HPA_COMMENTLINE = stc.wxSTC_HPA_COMMENTLINE  # 107
-wxSTC_HPA_DEFAULT = stc.wxSTC_HPA_DEFAULT  # 106
-wxSTC_HPA_DEFNAME = stc.wxSTC_HPA_DEFNAME  # 115
-wxSTC_HPA_IDENTIFIER = stc.wxSTC_HPA_IDENTIFIER  # 117
-wxSTC_HPA_NUMBER = stc.wxSTC_HPA_NUMBER  # 108
-wxSTC_HPA_OPERATOR = stc.wxSTC_HPA_OPERATOR  # 116
-wxSTC_HPA_START = stc.wxSTC_HPA_START  # 105
-wxSTC_HPA_STRING = stc.wxSTC_HPA_STRING  # 109
-wxSTC_HPA_TRIPLE = stc.wxSTC_HPA_TRIPLE  # 112
-wxSTC_HPA_TRIPLEDOUBLE = stc.wxSTC_HPA_TRIPLEDOUBLE  # 113
-wxSTC_HPA_WORD = stc.wxSTC_HPA_WORD  # 111
-wxSTC_HPHP_COMMENT = stc.wxSTC_HPHP_COMMENT  # 124
-wxSTC_HPHP_COMMENTLINE = stc.wxSTC_HPHP_COMMENTLINE  # 125
-wxSTC_HPHP_DEFAULT = stc.wxSTC_HPHP_DEFAULT  # 118
-wxSTC_HPHP_HSTRING = stc.wxSTC_HPHP_HSTRING  # 119
-wxSTC_HPHP_HSTRING_VARIABLE = stc.wxSTC_HPHP_HSTRING_VARIABLE  # 126
-wxSTC_HPHP_NUMBER = stc.wxSTC_HPHP_NUMBER  # 122
-wxSTC_HPHP_OPERATOR = stc.wxSTC_HPHP_OPERATOR  # 127
-wxSTC_HPHP_SIMPLESTRING = stc.wxSTC_HPHP_SIMPLESTRING  # 120
-wxSTC_HPHP_VARIABLE = stc.wxSTC_HPHP_VARIABLE  # 123
-wxSTC_HPHP_WORD = stc.wxSTC_HPHP_WORD  # 121
-wxSTC_HP_CHARACTER = stc.wxSTC_HP_CHARACTER  # 95
-wxSTC_HP_CLASSNAME = stc.wxSTC_HP_CLASSNAME  # 99
-wxSTC_HP_COMMENTLINE = stc.wxSTC_HP_COMMENTLINE  # 92
-wxSTC_HP_DEFAULT = stc.wxSTC_HP_DEFAULT  # 91
-wxSTC_HP_DEFNAME = stc.wxSTC_HP_DEFNAME  # 100
-wxSTC_HP_IDENTIFIER = stc.wxSTC_HP_IDENTIFIER  # 102
-wxSTC_HP_NUMBER = stc.wxSTC_HP_NUMBER  # 93
-wxSTC_HP_OPERATOR = stc.wxSTC_HP_OPERATOR  # 101
-wxSTC_HP_START = stc.wxSTC_HP_START  # 90
-wxSTC_HP_STRING = stc.wxSTC_HP_STRING  # 94
-wxSTC_HP_TRIPLE = stc.wxSTC_HP_TRIPLE  # 97
-wxSTC_HP_TRIPLEDOUBLE = stc.wxSTC_HP_TRIPLEDOUBLE  # 98
-wxSTC_HP_WORD = stc.wxSTC_HP_WORD  # 96
-wxSTC_H_ASP = stc.wxSTC_H_ASP  # 15
-wxSTC_H_ASPAT = stc.wxSTC_H_ASPAT  # 16
-wxSTC_H_ATTRIBUTE = stc.wxSTC_H_ATTRIBUTE  # 3
-wxSTC_H_ATTRIBUTEUNKNOWN = stc.wxSTC_H_ATTRIBUTEUNKNOWN  # 4
-wxSTC_H_CDATA = stc.wxSTC_H_CDATA  # 17
-wxSTC_H_COMMENT = stc.wxSTC_H_COMMENT  # 9
-wxSTC_H_DEFAULT = stc.wxSTC_H_DEFAULT  # 0
-wxSTC_H_DOUBLESTRING = stc.wxSTC_H_DOUBLESTRING  # 6
-wxSTC_H_ENTITY = stc.wxSTC_H_ENTITY  # 10
-wxSTC_H_NUMBER = stc.wxSTC_H_NUMBER  # 5
-wxSTC_H_OTHER = stc.wxSTC_H_OTHER  # 8
-wxSTC_H_QUESTION = stc.wxSTC_H_QUESTION  # 18
-wxSTC_H_SCRIPT = stc.wxSTC_H_SCRIPT  # 14
-wxSTC_H_SGML_1ST_PARAM = stc.wxSTC_H_SGML_1ST_PARAM  # 23
-wxSTC_H_SGML_1ST_PARAM_COMMENT = stc.wxSTC_H_SGML_1ST_PARAM_COMMENT  # 30
-wxSTC_H_SGML_BLOCK_DEFAULT = stc.wxSTC_H_SGML_BLOCK_DEFAULT  # 31
-wxSTC_H_SGML_COMMAND = stc.wxSTC_H_SGML_COMMAND  # 22
-wxSTC_H_SGML_COMMENT = stc.wxSTC_H_SGML_COMMENT  # 29
-wxSTC_H_SGML_DEFAULT = stc.wxSTC_H_SGML_DEFAULT  # 21
-wxSTC_H_SGML_DOUBLESTRING = stc.wxSTC_H_SGML_DOUBLESTRING  # 24
-wxSTC_H_SGML_ENTITY = stc.wxSTC_H_SGML_ENTITY  # 28
-wxSTC_H_SGML_ERROR = stc.wxSTC_H_SGML_ERROR  # 26
-wxSTC_H_SGML_SIMPLESTRING = stc.wxSTC_H_SGML_SIMPLESTRING  # 25
-wxSTC_H_SGML_SPECIAL = stc.wxSTC_H_SGML_SPECIAL  # 27
-wxSTC_H_SINGLESTRING = stc.wxSTC_H_SINGLESTRING  # 7
-wxSTC_H_TAG = stc.wxSTC_H_TAG  # 1
-wxSTC_H_TAGEND = stc.wxSTC_H_TAGEND  # 11
-wxSTC_H_TAGUNKNOWN = stc.wxSTC_H_TAGUNKNOWN  # 2
-wxSTC_H_VALUE = stc.wxSTC_H_VALUE  # 19
-wxSTC_H_XCCOMMENT = stc.wxSTC_H_XCCOMMENT  # 20
-wxSTC_H_XMLEND = stc.wxSTC_H_XMLEND  # 13
-wxSTC_H_XMLSTART = stc.wxSTC_H_XMLSTART  # 12
-wxSTC_INDIC0_MASK = stc.wxSTC_INDIC0_MASK  # 32
-wxSTC_INDIC1_MASK = stc.wxSTC_INDIC1_MASK  # 64
-wxSTC_INDIC2_MASK = stc.wxSTC_INDIC2_MASK  # 128
-wxSTC_INDICS_MASK = stc.wxSTC_INDICS_MASK  # 224
-wxSTC_INDIC_DIAGONAL = stc.wxSTC_INDIC_DIAGONAL  # 3
-wxSTC_INDIC_MAX = stc.wxSTC_INDIC_MAX  # 7
-wxSTC_INDIC_PLAIN = stc.wxSTC_INDIC_PLAIN  # 0
-wxSTC_INDIC_SQUIGGLE = stc.wxSTC_INDIC_SQUIGGLE  # 1
-wxSTC_INDIC_STRIKE = stc.wxSTC_INDIC_STRIKE  # 4
-wxSTC_INDIC_TT = stc.wxSTC_INDIC_TT  # 2
-wxSTC_INVALID_POSITION = stc.wxSTC_INVALID_POSITION  # -1
-wxSTC_KEY_ADD = stc.wxSTC_KEY_ADD  # 310
-wxSTC_KEY_BACK = stc.wxSTC_KEY_BACK  # 8
-wxSTC_KEY_DELETE = stc.wxSTC_KEY_DELETE  # 308
-wxSTC_KEY_DIVIDE = stc.wxSTC_KEY_DIVIDE  # 312
-wxSTC_KEY_DOWN = stc.wxSTC_KEY_DOWN  # 300
-wxSTC_KEY_END = stc.wxSTC_KEY_END  # 305
-wxSTC_KEY_ESCAPE = stc.wxSTC_KEY_ESCAPE  # 7
-wxSTC_KEY_HOME = stc.wxSTC_KEY_HOME  # 304
-wxSTC_KEY_INSERT = stc.wxSTC_KEY_INSERT  # 309
-wxSTC_KEY_LEFT = stc.wxSTC_KEY_LEFT  # 302
-wxSTC_KEY_NEXT = stc.wxSTC_KEY_NEXT  # 307
-wxSTC_KEY_PRIOR = stc.wxSTC_KEY_PRIOR  # 306
-wxSTC_KEY_RETURN = stc.wxSTC_KEY_RETURN  # 13
-wxSTC_KEY_RIGHT = stc.wxSTC_KEY_RIGHT  # 303
-wxSTC_KEY_SUBTRACT = stc.wxSTC_KEY_SUBTRACT  # 311
-wxSTC_KEY_TAB = stc.wxSTC_KEY_TAB  # 9
-wxSTC_KEY_UP = stc.wxSTC_KEY_UP  # 301
-wxSTC_LASTSTEPINUNDOREDO = stc.wxSTC_LASTSTEPINUNDOREDO  # 256
-wxSTC_LEXER_START = stc.wxSTC_LEXER_START  # 4000
-wxSTC_LEX_ADA = stc.wxSTC_LEX_ADA  # 20
-wxSTC_LEX_ASP = stc.wxSTC_LEX_ASP  # 29
-wxSTC_LEX_AUTOMATIC = stc.wxSTC_LEX_AUTOMATIC  # 1000
-wxSTC_LEX_AVE = stc.wxSTC_LEX_AVE  # 19
-wxSTC_LEX_BAAN = stc.wxSTC_LEX_BAAN  # 31
-wxSTC_LEX_BATCH = stc.wxSTC_LEX_BATCH  # 12
-wxSTC_LEX_BULLANT = stc.wxSTC_LEX_BULLANT  # 27
-wxSTC_LEX_CONF = stc.wxSTC_LEX_CONF  # 17
-wxSTC_LEX_CONTAINER = stc.wxSTC_LEX_CONTAINER  # 0
-wxSTC_LEX_CPP = stc.wxSTC_LEX_CPP  # 3
-wxSTC_LEX_DIFF = stc.wxSTC_LEX_DIFF  # 16
-wxSTC_LEX_EIFFEL = stc.wxSTC_LEX_EIFFEL  # 23
-wxSTC_LEX_EIFFELKW = stc.wxSTC_LEX_EIFFELKW  # 24
-wxSTC_LEX_ERRORLIST = stc.wxSTC_LEX_ERRORLIST  # 10
-wxSTC_LEX_HTML = stc.wxSTC_LEX_HTML  # 4
-wxSTC_LEX_LATEX = stc.wxSTC_LEX_LATEX  # 14
-wxSTC_LEX_LISP = stc.wxSTC_LEX_LISP  # 21
-wxSTC_LEX_LUA = stc.wxSTC_LEX_LUA  # 15
-wxSTC_LEX_MAKEFILE = stc.wxSTC_LEX_MAKEFILE  # 11
-wxSTC_LEX_MATLAB = stc.wxSTC_LEX_MATLAB  # 32
-wxSTC_LEX_NNCRONTAB = stc.wxSTC_LEX_NNCRONTAB  # 26
-wxSTC_LEX_NULL = stc.wxSTC_LEX_NULL  # 1
-wxSTC_LEX_PASCAL = stc.wxSTC_LEX_PASCAL  # 18
-wxSTC_LEX_PERL = stc.wxSTC_LEX_PERL  # 6
-wxSTC_LEX_PHP = stc.wxSTC_LEX_PHP  # 30
-wxSTC_LEX_PROPERTIES = stc.wxSTC_LEX_PROPERTIES  # 9
-wxSTC_LEX_PYTHON = stc.wxSTC_LEX_PYTHON  # 2
-wxSTC_LEX_RUBY = stc.wxSTC_LEX_RUBY  # 22
-wxSTC_LEX_SCRIPTOL = stc.wxSTC_LEX_SCRIPTOL  # 33
-wxSTC_LEX_SQL = stc.wxSTC_LEX_SQL  # 7
-wxSTC_LEX_TCL = stc.wxSTC_LEX_TCL  # 25
-wxSTC_LEX_VB = stc.wxSTC_LEX_VB  # 8
-wxSTC_LEX_VBSCRIPT = stc.wxSTC_LEX_VBSCRIPT  # 28
-wxSTC_LEX_XCODE = stc.wxSTC_LEX_XCODE  # 13
-wxSTC_LEX_XML = stc.wxSTC_LEX_XML  # 5
-wxSTC_LISP_COMMENT = stc.wxSTC_LISP_COMMENT  # 1
-wxSTC_LISP_DEFAULT = stc.wxSTC_LISP_DEFAULT  # 0
-wxSTC_LISP_IDENTIFIER = stc.wxSTC_LISP_IDENTIFIER  # 9
-wxSTC_LISP_KEYWORD = stc.wxSTC_LISP_KEYWORD  # 3
-wxSTC_LISP_NUMBER = stc.wxSTC_LISP_NUMBER  # 2
-wxSTC_LISP_OPERATOR = stc.wxSTC_LISP_OPERATOR  # 10
-wxSTC_LISP_STRING = stc.wxSTC_LISP_STRING  # 6
-wxSTC_LISP_STRINGEOL = stc.wxSTC_LISP_STRINGEOL  # 8
-wxSTC_LUA_CHARACTER = stc.wxSTC_LUA_CHARACTER  # 7
-wxSTC_LUA_COMMENT = stc.wxSTC_LUA_COMMENT  # 1
-wxSTC_LUA_COMMENTDOC = stc.wxSTC_LUA_COMMENTDOC  # 3
-wxSTC_LUA_COMMENTLINE = stc.wxSTC_LUA_COMMENTLINE  # 2
-wxSTC_LUA_DEFAULT = stc.wxSTC_LUA_DEFAULT  # 0
-wxSTC_LUA_IDENTIFIER = stc.wxSTC_LUA_IDENTIFIER  # 11
-wxSTC_LUA_LITERALSTRING = stc.wxSTC_LUA_LITERALSTRING  # 8
-wxSTC_LUA_NUMBER = stc.wxSTC_LUA_NUMBER  # 4
-wxSTC_LUA_OPERATOR = stc.wxSTC_LUA_OPERATOR  # 10
-wxSTC_LUA_PREPROCESSOR = stc.wxSTC_LUA_PREPROCESSOR  # 9
-wxSTC_LUA_STRING = stc.wxSTC_LUA_STRING  # 6
-wxSTC_LUA_STRINGEOL = stc.wxSTC_LUA_STRINGEOL  # 12
-wxSTC_LUA_WORD = stc.wxSTC_LUA_WORD  # 5
-wxSTC_LUA_WORD2 = stc.wxSTC_LUA_WORD2  # 13
-wxSTC_LUA_WORD3 = stc.wxSTC_LUA_WORD3  # 14
-wxSTC_LUA_WORD4 = stc.wxSTC_LUA_WORD4  # 15
-wxSTC_LUA_WORD5 = stc.wxSTC_LUA_WORD5  # 16
-wxSTC_LUA_WORD6 = stc.wxSTC_LUA_WORD6  # 17
-wxSTC_L_COMMAND = stc.wxSTC_L_COMMAND  # 1
-wxSTC_L_COMMENT = stc.wxSTC_L_COMMENT  # 4
-wxSTC_L_DEFAULT = stc.wxSTC_L_DEFAULT  # 0
-wxSTC_L_MATH = stc.wxSTC_L_MATH  # 3
-wxSTC_L_TAG = stc.wxSTC_L_TAG  # 2
-wxSTC_MAKE_COMMENT = stc.wxSTC_MAKE_COMMENT  # 1
-wxSTC_MAKE_DEFAULT = stc.wxSTC_MAKE_DEFAULT  # 0
-wxSTC_MAKE_IDENTIFIER = stc.wxSTC_MAKE_IDENTIFIER  # 3
-wxSTC_MAKE_IDEOL = stc.wxSTC_MAKE_IDEOL  # 9
-wxSTC_MAKE_OPERATOR = stc.wxSTC_MAKE_OPERATOR  # 4
-wxSTC_MAKE_PREPROCESSOR = stc.wxSTC_MAKE_PREPROCESSOR  # 2
-wxSTC_MAKE_TARGET = stc.wxSTC_MAKE_TARGET  # 5
-wxSTC_MARGIN_NUMBER = stc.wxSTC_MARGIN_NUMBER  # 1
-wxSTC_MARGIN_SYMBOL = stc.wxSTC_MARGIN_SYMBOL  # 0
-wxSTC_MARKER_MAX = stc.wxSTC_MARKER_MAX  # 31
-wxSTC_MARKNUM_FOLDER = stc.wxSTC_MARKNUM_FOLDER  # 30
-wxSTC_MARKNUM_FOLDEREND = stc.wxSTC_MARKNUM_FOLDEREND  # 25
-wxSTC_MARKNUM_FOLDERMIDTAIL = stc.wxSTC_MARKNUM_FOLDERMIDTAIL  # 27
-wxSTC_MARKNUM_FOLDEROPEN = stc.wxSTC_MARKNUM_FOLDEROPEN  # 31
-wxSTC_MARKNUM_FOLDEROPENMID = stc.wxSTC_MARKNUM_FOLDEROPENMID  # 26
-wxSTC_MARKNUM_FOLDERSUB = stc.wxSTC_MARKNUM_FOLDERSUB  # 29
-wxSTC_MARKNUM_FOLDERTAIL = stc.wxSTC_MARKNUM_FOLDERTAIL  # 28
-wxSTC_MARK_ARROW = stc.wxSTC_MARK_ARROW  # 2
-wxSTC_MARK_ARROWDOWN = stc.wxSTC_MARK_ARROWDOWN  # 6
-wxSTC_MARK_ARROWS = stc.wxSTC_MARK_ARROWS  # 24
-wxSTC_MARK_BACKGROUND = stc.wxSTC_MARK_BACKGROUND  # 22
-wxSTC_MARK_BOXMINUS = stc.wxSTC_MARK_BOXMINUS  # 14
-wxSTC_MARK_BOXMINUSCONNECTED = stc.wxSTC_MARK_BOXMINUSCONNECTED  # 15
-wxSTC_MARK_BOXPLUS = stc.wxSTC_MARK_BOXPLUS  # 12
-wxSTC_MARK_BOXPLUSCONNECTED = stc.wxSTC_MARK_BOXPLUSCONNECTED  # 13
-wxSTC_MARK_CHARACTER = stc.wxSTC_MARK_CHARACTER  # 10000
-wxSTC_MARK_CIRCLE = stc.wxSTC_MARK_CIRCLE  # 0
-wxSTC_MARK_CIRCLEMINUS = stc.wxSTC_MARK_CIRCLEMINUS  # 20
-wxSTC_MARK_CIRCLEMINUSCONNECTED = stc.wxSTC_MARK_CIRCLEMINUSCONNECTED  # 21
-wxSTC_MARK_CIRCLEPLUS = stc.wxSTC_MARK_CIRCLEPLUS  # 18
-wxSTC_MARK_CIRCLEPLUSCONNECTED = stc.wxSTC_MARK_CIRCLEPLUSCONNECTED  # 19
-wxSTC_MARK_DOTDOTDOT = stc.wxSTC_MARK_DOTDOTDOT  # 23
-wxSTC_MARK_EMPTY = stc.wxSTC_MARK_EMPTY  # 5
-wxSTC_MARK_LCORNER = stc.wxSTC_MARK_LCORNER  # 10
-wxSTC_MARK_LCORNERCURVE = stc.wxSTC_MARK_LCORNERCURVE  # 16
-wxSTC_MARK_MINUS = stc.wxSTC_MARK_MINUS  # 7
-wxSTC_MARK_PLUS = stc.wxSTC_MARK_PLUS  # 8
-wxSTC_MARK_ROUNDRECT = stc.wxSTC_MARK_ROUNDRECT  # 1
-wxSTC_MARK_SHORTARROW = stc.wxSTC_MARK_SHORTARROW  # 4
-wxSTC_MARK_SMALLRECT = stc.wxSTC_MARK_SMALLRECT  # 3
-wxSTC_MARK_TCORNER = stc.wxSTC_MARK_TCORNER  # 11
-wxSTC_MARK_TCORNERCURVE = stc.wxSTC_MARK_TCORNERCURVE  # 17
-wxSTC_MARK_VLINE = stc.wxSTC_MARK_VLINE  # 9
-wxSTC_MASK_FOLDERS = stc.wxSTC_MASK_FOLDERS  # -33554432
-wxSTC_MATLAB_COMMAND = stc.wxSTC_MATLAB_COMMAND  # 2
-wxSTC_MATLAB_COMMENT = stc.wxSTC_MATLAB_COMMENT  # 1
-wxSTC_MATLAB_DEFAULT = stc.wxSTC_MATLAB_DEFAULT  # 0
-wxSTC_MATLAB_IDENTIFIER = stc.wxSTC_MATLAB_IDENTIFIER  # 7
-wxSTC_MATLAB_KEYWORD = stc.wxSTC_MATLAB_KEYWORD  # 4
-wxSTC_MATLAB_NUMBER = stc.wxSTC_MATLAB_NUMBER  # 3
-wxSTC_MATLAB_OPERATOR = stc.wxSTC_MATLAB_OPERATOR  # 6
-wxSTC_MATLAB_STRING = stc.wxSTC_MATLAB_STRING  # 5
-wxSTC_MODEVENTMASKALL = stc.wxSTC_MODEVENTMASKALL  # 3959
-wxSTC_MOD_BEFOREDELETE = stc.wxSTC_MOD_BEFOREDELETE  # 2048
-wxSTC_MOD_BEFOREINSERT = stc.wxSTC_MOD_BEFOREINSERT  # 1024
-wxSTC_MOD_CHANGEFOLD = stc.wxSTC_MOD_CHANGEFOLD  # 8
-wxSTC_MOD_CHANGEMARKER = stc.wxSTC_MOD_CHANGEMARKER  # 512
-wxSTC_MOD_CHANGESTYLE = stc.wxSTC_MOD_CHANGESTYLE  # 4
-wxSTC_MOD_DELETETEXT = stc.wxSTC_MOD_DELETETEXT  # 2
-wxSTC_MOD_INSERTTEXT = stc.wxSTC_MOD_INSERTTEXT  # 1
-wxSTC_NNCRONTAB_ASTERISK = stc.wxSTC_NNCRONTAB_ASTERISK  # 6
-wxSTC_NNCRONTAB_COMMENT = stc.wxSTC_NNCRONTAB_COMMENT  # 1
-wxSTC_NNCRONTAB_DEFAULT = stc.wxSTC_NNCRONTAB_DEFAULT  # 0
-wxSTC_NNCRONTAB_ENVIRONMENT = stc.wxSTC_NNCRONTAB_ENVIRONMENT  # 9
-wxSTC_NNCRONTAB_IDENTIFIER = stc.wxSTC_NNCRONTAB_IDENTIFIER  # 10
-wxSTC_NNCRONTAB_KEYWORD = stc.wxSTC_NNCRONTAB_KEYWORD  # 4
-wxSTC_NNCRONTAB_MODIFIER = stc.wxSTC_NNCRONTAB_MODIFIER  # 5
-wxSTC_NNCRONTAB_NUMBER = stc.wxSTC_NNCRONTAB_NUMBER  # 7
-wxSTC_NNCRONTAB_SECTION = stc.wxSTC_NNCRONTAB_SECTION  # 3
-wxSTC_NNCRONTAB_STRING = stc.wxSTC_NNCRONTAB_STRING  # 8
-wxSTC_NNCRONTAB_TASK = stc.wxSTC_NNCRONTAB_TASK  # 2
-wxSTC_OPTIONAL_START = stc.wxSTC_OPTIONAL_START  # 3000
-wxSTC_PERFORMED_REDO = stc.wxSTC_PERFORMED_REDO  # 64
-wxSTC_PERFORMED_UNDO = stc.wxSTC_PERFORMED_UNDO  # 32
-wxSTC_PERFORMED_USER = stc.wxSTC_PERFORMED_USER  # 16
-wxSTC_PL_ARRAY = stc.wxSTC_PL_ARRAY  # 13
-wxSTC_PL_BACKTICKS = stc.wxSTC_PL_BACKTICKS  # 20
-wxSTC_PL_CHARACTER = stc.wxSTC_PL_CHARACTER  # 7
-wxSTC_PL_COMMENTLINE = stc.wxSTC_PL_COMMENTLINE  # 2
-wxSTC_PL_DATASECTION = stc.wxSTC_PL_DATASECTION  # 21
-wxSTC_PL_DEFAULT = stc.wxSTC_PL_DEFAULT  # 0
-wxSTC_PL_ERROR = stc.wxSTC_PL_ERROR  # 1
-wxSTC_PL_HASH = stc.wxSTC_PL_HASH  # 14
-wxSTC_PL_HERE_DELIM = stc.wxSTC_PL_HERE_DELIM  # 22
-wxSTC_PL_HERE_Q = stc.wxSTC_PL_HERE_Q  # 23
-wxSTC_PL_HERE_QQ = stc.wxSTC_PL_HERE_QQ  # 24
-wxSTC_PL_HERE_QX = stc.wxSTC_PL_HERE_QX  # 25
-wxSTC_PL_IDENTIFIER = stc.wxSTC_PL_IDENTIFIER  # 11
-wxSTC_PL_LONGQUOTE = stc.wxSTC_PL_LONGQUOTE  # 19
-wxSTC_PL_NUMBER = stc.wxSTC_PL_NUMBER  # 4
-wxSTC_PL_OPERATOR = stc.wxSTC_PL_OPERATOR  # 10
-wxSTC_PL_POD = stc.wxSTC_PL_POD  # 3
-wxSTC_PL_PREPROCESSOR = stc.wxSTC_PL_PREPROCESSOR  # 9
-wxSTC_PL_PUNCTUATION = stc.wxSTC_PL_PUNCTUATION  # 8
-wxSTC_PL_REGEX = stc.wxSTC_PL_REGEX  # 17
-wxSTC_PL_REGSUBST = stc.wxSTC_PL_REGSUBST  # 18
-wxSTC_PL_SCALAR = stc.wxSTC_PL_SCALAR  # 12
-wxSTC_PL_STRING = stc.wxSTC_PL_STRING  # 6
-wxSTC_PL_STRING_Q = stc.wxSTC_PL_STRING_Q  # 26
-wxSTC_PL_STRING_QQ = stc.wxSTC_PL_STRING_QQ  # 27
-wxSTC_PL_STRING_QR = stc.wxSTC_PL_STRING_QR  # 29
-wxSTC_PL_STRING_QW = stc.wxSTC_PL_STRING_QW  # 30
-wxSTC_PL_STRING_QX = stc.wxSTC_PL_STRING_QX  # 28
-wxSTC_PL_SYMBOLTABLE = stc.wxSTC_PL_SYMBOLTABLE  # 15
-wxSTC_PL_WORD = stc.wxSTC_PL_WORD  # 5
-wxSTC_PRINT_BLACKONWHITE = stc.wxSTC_PRINT_BLACKONWHITE  # 2
-wxSTC_PRINT_COLOURONWHITE = stc.wxSTC_PRINT_COLOURONWHITE  # 3
-wxSTC_PRINT_COLOURONWHITEDEFAULTBG = stc.wxSTC_PRINT_COLOURONWHITEDEFAULTBG  # 4
-wxSTC_PRINT_INVERTLIGHT = stc.wxSTC_PRINT_INVERTLIGHT  # 1
-wxSTC_PRINT_NORMAL = stc.wxSTC_PRINT_NORMAL  # 0
-wxSTC_PROPS_ASSIGNMENT = stc.wxSTC_PROPS_ASSIGNMENT  # 3
-wxSTC_PROPS_COMMENT = stc.wxSTC_PROPS_COMMENT  # 1
-wxSTC_PROPS_DEFAULT = stc.wxSTC_PROPS_DEFAULT  # 0
-wxSTC_PROPS_DEFVAL = stc.wxSTC_PROPS_DEFVAL  # 4
-wxSTC_PROPS_SECTION = stc.wxSTC_PROPS_SECTION  # 2
-wxSTC_P_CHARACTER = stc.wxSTC_P_CHARACTER  # 4
-wxSTC_P_CLASSNAME = stc.wxSTC_P_CLASSNAME  # 8
-wxSTC_P_COMMENTBLOCK = stc.wxSTC_P_COMMENTBLOCK  # 12
-wxSTC_P_COMMENTLINE = stc.wxSTC_P_COMMENTLINE  # 1
-wxSTC_P_DEFAULT = stc.wxSTC_P_DEFAULT  # 0
-wxSTC_P_DEFNAME = stc.wxSTC_P_DEFNAME  # 9
-wxSTC_P_IDENTIFIER = stc.wxSTC_P_IDENTIFIER  # 11
-wxSTC_P_NUMBER = stc.wxSTC_P_NUMBER  # 2
-wxSTC_P_OPERATOR = stc.wxSTC_P_OPERATOR  # 10
-wxSTC_P_STRING = stc.wxSTC_P_STRING  # 3
-wxSTC_P_STRINGEOL = stc.wxSTC_P_STRINGEOL  # 13
-wxSTC_P_TRIPLE = stc.wxSTC_P_TRIPLE  # 6
-wxSTC_P_TRIPLEDOUBLE = stc.wxSTC_P_TRIPLEDOUBLE  # 7
-wxSTC_P_WORD = stc.wxSTC_P_WORD  # 5
-wxSTC_SCMOD_ALT = stc.wxSTC_SCMOD_ALT  # 4
-wxSTC_SCMOD_CTRL = stc.wxSTC_SCMOD_CTRL  # 2
-wxSTC_SCMOD_SHIFT = stc.wxSTC_SCMOD_SHIFT  # 1
-wxSTC_SCRIPTOL_CHARACTER = stc.wxSTC_SCRIPTOL_CHARACTER  # 7
-wxSTC_SCRIPTOL_COMMENT = stc.wxSTC_SCRIPTOL_COMMENT  # 1
-wxSTC_SCRIPTOL_COMMENTBASIC = stc.wxSTC_SCRIPTOL_COMMENTBASIC  # 19
-wxSTC_SCRIPTOL_COMMENTDOC = stc.wxSTC_SCRIPTOL_COMMENTDOC  # 3
-wxSTC_SCRIPTOL_COMMENTDOCKEYWORD = stc.wxSTC_SCRIPTOL_COMMENTDOCKEYWORD  # 17
-wxSTC_SCRIPTOL_COMMENTDOCKEYWORDERROR = stc.wxSTC_SCRIPTOL_COMMENTDOCKEYWORDERROR  # 18
-wxSTC_SCRIPTOL_COMMENTLINE = stc.wxSTC_SCRIPTOL_COMMENTLINE  # 2
-wxSTC_SCRIPTOL_COMMENTLINEDOC = stc.wxSTC_SCRIPTOL_COMMENTLINEDOC  # 15
-wxSTC_SCRIPTOL_DEFAULT = stc.wxSTC_SCRIPTOL_DEFAULT  # 0
-wxSTC_SCRIPTOL_IDENTIFIER = stc.wxSTC_SCRIPTOL_IDENTIFIER  # 11
-wxSTC_SCRIPTOL_NUMBER = stc.wxSTC_SCRIPTOL_NUMBER  # 4
-wxSTC_SCRIPTOL_OPERATOR = stc.wxSTC_SCRIPTOL_OPERATOR  # 10
-wxSTC_SCRIPTOL_PREPROCESSOR = stc.wxSTC_SCRIPTOL_PREPROCESSOR  # 9
-wxSTC_SCRIPTOL_REGEX = stc.wxSTC_SCRIPTOL_REGEX  # 14
-wxSTC_SCRIPTOL_STRING = stc.wxSTC_SCRIPTOL_STRING  # 6
-wxSTC_SCRIPTOL_STRINGEOL = stc.wxSTC_SCRIPTOL_STRINGEOL  # 12
-wxSTC_SCRIPTOL_UUID = stc.wxSTC_SCRIPTOL_UUID  # 8
-wxSTC_SCRIPTOL_VERBATIM = stc.wxSTC_SCRIPTOL_VERBATIM  # 13
-wxSTC_SCRIPTOL_WORD = stc.wxSTC_SCRIPTOL_WORD  # 5
-wxSTC_SCRIPTOL_WORD2 = stc.wxSTC_SCRIPTOL_WORD2  # 16
-wxSTC_START = stc.wxSTC_START  # 2000
-wxSTC_STYLE_BRACEBAD = stc.wxSTC_STYLE_BRACEBAD  # 35
-wxSTC_STYLE_BRACELIGHT = stc.wxSTC_STYLE_BRACELIGHT  # 34
-wxSTC_STYLE_CONTROLCHAR = stc.wxSTC_STYLE_CONTROLCHAR  # 36
-wxSTC_STYLE_DEFAULT = stc.wxSTC_STYLE_DEFAULT  # 32
-wxSTC_STYLE_INDENTGUIDE = stc.wxSTC_STYLE_INDENTGUIDE  # 37
-wxSTC_STYLE_LASTPREDEFINED = stc.wxSTC_STYLE_LASTPREDEFINED  # 39
-wxSTC_STYLE_LINENUMBER = stc.wxSTC_STYLE_LINENUMBER  # 33
-wxSTC_STYLE_MAX = stc.wxSTC_STYLE_MAX  # 127
-wxSTC_TIME_FOREVER = stc.wxSTC_TIME_FOREVER  # 10000000
-wxSTC_USE_POPUP = stc.wxSTC_USE_POPUP  # 1
-wxSTC_VISIBLE_SLOP = stc.wxSTC_VISIBLE_SLOP  # 1
-wxSTC_VISIBLE_STRICT = stc.wxSTC_VISIBLE_STRICT  # 4
-wxSTC_WRAP_NONE = stc.wxSTC_WRAP_NONE  # 0
-wxSTC_WRAP_WORD = stc.wxSTC_WRAP_WORD  # 1
-wxSTC_WS_INVISIBLE = stc.wxSTC_WS_INVISIBLE  # 0
-wxSTC_WS_VISIBLEAFTERINDENT = stc.wxSTC_WS_VISIBLEAFTERINDENT  # 2
-wxSTC_WS_VISIBLEALWAYS = stc.wxSTC_WS_VISIBLEALWAYS  # 1
-# End generated constants.

wxPython/wxPython/py/wxd/Threading.py

@@ -1,26 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class MutexGuiLocker:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/ToolBar.py

@@ -1,403 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Controls import Control
-import Parameters as wx
-
-
-class ToolBarBase(Control):
-    """"""
-
-    def AddCheckLabelTool(self):
-        """"""
-        pass
-
-    def AddCheckTool(self):
-        """"""
-        pass
-
-    def AddControl(self):
-        """"""
-        pass
-
-    def AddLabelTool(self):
-        """"""
-        pass
-
-    def AddRadioLabelTool(self):
-        """"""
-        pass
-
-    def AddRadioTool(self):
-        """"""
-        pass
-
-    def AddSeparator(self):
-        """"""
-        pass
-
-    def AddSimpleTool(self):
-        """"""
-        pass
-
-    def AddTool(self):
-        """"""
-        pass
-
-    def ClearTools(self):
-        """"""
-        pass
-
-    def DeleteTool(self):
-        """"""
-        pass
-
-    def DeleteToolByPos(self):
-        """"""
-        pass
-
-    def DoAddTool(self):
-        """"""
-        pass
-
-    def DoInsertTool(self):
-        """"""
-        pass
-
-    def EnableTool(self):
-        """"""
-        pass
-
-    def FindControl(self):
-        """"""
-        pass
-
-    def FindToolForPosition(self):
-        """"""
-        pass
-
-    def GetMargins(self):
-        """"""
-        pass
-
-    def GetMaxCols(self):
-        """"""
-        pass
-
-    def GetMaxRows(self):
-        """"""
-        pass
-
-    def GetToolBitmapSize(self):
-        """"""
-        pass
-
-    def GetToolClientData(self):
-        """"""
-        pass
-
-    def GetToolEnabled(self):
-        """"""
-        pass
-
-    def GetToolLongHelp(self):
-        """"""
-        pass
-
-    def GetToolMargins(self):
-        """"""
-        pass
-
-    def GetToolPacking(self):
-        """"""
-        pass
-
-    def GetToolSeparation(self):
-        """"""
-        pass
-
-    def GetToolShortHelp(self):
-        """"""
-        pass
-
-    def GetToolSize(self):
-        """"""
-        pass
-
-    def GetToolState(self):
-        """"""
-        pass
-
-    def InsertControl(self):
-        """"""
-        pass
-
-    def InsertLabelTool(self):
-        """"""
-        pass
-
-    def InsertSeparator(self):
-        """"""
-        pass
-
-    def InsertSimpleTool(self):
-        """"""
-        pass
-
-    def InsertTool(self):
-        """"""
-        pass
-
-    def IsVertical(self):
-        """"""
-        pass
-
-    def Realize(self):
-        """"""
-        pass
-
-    def RemoveTool(self):
-        """"""
-        pass
-
-    def SetMargins(self):
-        """"""
-        pass
-
-    def SetMarginsXY(self):
-        """"""
-        pass
-
-    def SetMaxRowsCols(self):
-        """"""
-        pass
-
-    def SetRows(self):
-        """"""
-        pass
-
-    def SetToggle(self):
-        """"""
-        pass
-
-    def SetToolBitmapSize(self):
-        """"""
-        pass
-
-    def SetToolClientData(self):
-        """"""
-        pass
-
-    def SetToolLongHelp(self):
-        """"""
-        pass
-
-    def SetToolPacking(self):
-        """"""
-        pass
-
-    def SetToolSeparation(self):
-        """"""
-        pass
-
-    def SetToolShortHelp(self):
-        """"""
-        pass
-
-    def ToggleTool(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolBar(ToolBarBase):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def FindToolForPosition(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolBarSimple(ToolBarBase):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def FindToolForPosition(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolBarToolBase(Object):
-    """"""
-
-    def Attach(self):
-        """"""
-        pass
-
-    def CanBeToggled(self):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def Detach(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def GetBitmap1(self):
-        """"""
-        pass
-
-    def GetBitmap2(self):
-        """"""
-        pass
-
-    def GetClientData(self):
-        """"""
-        pass
-
-    def GetControl(self):
-        """"""
-        pass
-
-    def GetDisabledBitmap(self):
-        """"""
-        pass
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetKind(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetLongHelp(self):
-        """"""
-        pass
-
-    def GetNormalBitmap(self):
-        """"""
-        pass
-
-    def GetShortHelp(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetToolBar(self):
-        """"""
-        pass
-
-    def IsButton(self):
-        """"""
-        pass
-
-    def IsControl(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsSeparator(self):
-        """"""
-        pass
-
-    def IsToggled(self):
-        """"""
-        pass
-
-    def SetBitmap1(self):
-        """"""
-        pass
-
-    def SetBitmap2(self):
-        """"""
-        pass
-
-    def SetClientData(self):
-        """"""
-        pass
-
-    def SetDisabledBitmap(self):
-        """"""
-        pass
-
-    def SetLabel(self):
-        """"""
-        pass
-
-    def SetLongHelp(self):
-        """"""
-        pass
-
-    def SetNormalBitmap(self):
-        """"""
-        pass
-
-    def SetShortHelp(self):
-        """"""
-        pass
-
-    def SetToggle(self):
-        """"""
-        pass
-
-    def Toggle(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Tree.py

@@ -1,403 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Controls import Control
-import Parameters as wx
-
-
-class TreeCtrl(Control):
-    """A tree control presents information as a hierarchy, with items
-    that may be expanded to show further items. Items in a tree
-    control are referenced by wx.TreeItemId handles, which may be
-    tested for validity by calling TreeItemId.IsOk()."""
-
-    def AddRoot(self):
-        """"""
-        pass
-
-    def AppendItem(self):
-        """"""
-        pass
-
-    def AssignImageList(self):
-        """"""
-        pass
-
-    def AssignStateImageList(self):
-        """"""
-        pass
-
-    def Collapse(self):
-        """"""
-        pass
-
-    def CollapseAndReset(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def Delete(self):
-        """"""
-        pass
-
-    def DeleteAllItems(self):
-        """"""
-        pass
-
-    def DeleteChildren(self):
-        """"""
-        pass
-
-    def EditLabel(self):
-        """"""
-        pass
-
-    def EnsureVisible(self):
-        """"""
-        pass
-
-    def Expand(self):
-        """"""
-        pass
-
-    def GetBoundingRect(self):
-        """"""
-        pass
-
-    def GetChildrenCount(self):
-        """"""
-        pass
-
-    def GetCount(self):
-        """"""
-        pass
-
-    def GetEditControl(self):
-        """"""
-        pass
-
-    def GetFirstChild(self):
-        """"""
-        pass
-
-    def GetFirstVisibleItem(self):
-        """"""
-        pass
-
-    def GetImageList(self):
-        """"""
-        pass
-
-    def GetIndent(self):
-        """"""
-        pass
-
-    def GetItemBackgroundColour(self):
-        """"""
-        pass
-
-    def GetItemData(self):
-        """"""
-        pass
-
-    def GetItemFont(self):
-        """"""
-        pass
-
-    def GetItemImage(self):
-        """"""
-        pass
-
-    def GetItemParent(self):
-        """"""
-        pass
-
-    def GetItemSelectedImage(self):
-        """"""
-        pass
-
-    def GetItemText(self):
-        """"""
-        pass
-
-    def GetItemTextColour(self):
-        """"""
-        pass
-
-    def GetLastChild(self):
-        """"""
-        pass
-
-    def GetNextChild(self):
-        """"""
-        pass
-
-    def GetNextSibling(self):
-        """"""
-        pass
-
-    def GetNextVisible(self):
-        """"""
-        pass
-
-    def GetPrevSibling(self):
-        """"""
-        pass
-
-    def GetPrevVisible(self):
-        """"""
-        pass
-
-    def GetPyData(self):
-        """"""
-        pass
-
-    def GetRootItem(self):
-        """"""
-        pass
-
-    def GetSelection(self):
-        """"""
-        pass
-
-    def GetSelections(self):
-        """"""
-        pass
-
-    def GetSpacing(self):
-        """"""
-        pass
-
-    def GetStateImageList(self):
-        """"""
-        pass
-
-    def HitTest(self):
-        """"""
-        pass
-
-    def InsertItem(self):
-        """"""
-        pass
-
-    def InsertItemBefore(self):
-        """"""
-        pass
-
-    def IsBold(self):
-        """"""
-        pass
-
-    def IsExpanded(self):
-        """"""
-        pass
-
-    def IsSelected(self):
-        """"""
-        pass
-
-    def IsVisible(self):
-        """"""
-        pass
-
-    def ItemHasChildren(self):
-        """"""
-        pass
-
-    def PrependItem(self):
-        """"""
-        pass
-
-    def ScrollTo(self):
-        """"""
-        pass
-
-    def SelectItem(self):
-        """"""
-        pass
-
-    def SetImageList(self):
-        """"""
-        pass
-
-    def SetIndent(self):
-        """"""
-        pass
-
-    def SetItemBackgroundColour(self):
-        """"""
-        pass
-
-    def SetItemBold(self):
-        """"""
-        pass
-
-    def SetItemData(self):
-        """"""
-        pass
-
-    def SetItemFont(self):
-        """"""
-        pass
-
-    def SetItemHasChildren(self):
-        """"""
-        pass
-
-    def SetItemImage(self):
-        """"""
-        pass
-
-    def SetItemSelectedImage(self):
-        """"""
-        pass
-
-    def SetItemText(self):
-        """"""
-        pass
-
-    def SetItemTextColour(self):
-        """"""
-        pass
-
-    def SetPyData(self):
-        """"""
-        pass
-
-    def SetSpacing(self):
-        """"""
-        pass
-
-    def SetStateImageList(self):
-        """"""
-        pass
-
-    def SortChildren(self):
-        """"""
-        pass
-
-    def Toggle(self):
-        """"""
-        pass
-
-    def Unselect(self):
-        """"""
-        pass
-
-    def UnselectAll(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TreeItemAttr:
-    """"""
-
-    def GetBackgroundColour(self):
-        """"""
-        pass
-
-    def GetFont(self):
-        """"""
-        pass
-
-    def GetTextColour(self):
-        """"""
-        pass
-
-    def HasBackgroundColour(self):
-        """"""
-        pass
-
-    def HasFont(self):
-        """"""
-        pass
-
-    def HasTextColour(self):
-        """"""
-        pass
-
-    def SetBackgroundColour(self):
-        """"""
-        pass
-
-    def SetFont(self):
-        """"""
-        pass
-
-    def SetTextColour(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class TreeItemData(Object):
-    """TreeItemData is some (arbitrary) user class associated with
-    some item. The main advantage of having this class is that
-    TreeItemData objects are destroyed automatically by the tree and
-    the memory and any other resources associated with a tree item
-    will be automatically freed when it is deleted."""
-
-    def __init__(self, obj=wx.NULL):
-        """Associate any Python object with tree item using
-        wxTreeItemData as container."""
-        pass
-
-    def GetData(self):
-        """Return the Python object."""
-        pass
-
-    def GetId(self):
-        """Return the item associated with this node."""
-        pass
-
-    def SetData(self, obj):
-        """Associate Python object with tree item."""
-        pass
-
-    def SetId(self, id):
-        """Set the item associated with this node."""
-        pass
-
-
-class TreeItemId:
-    """Item in a TreeCtrl."""
-
-## You wouldn't create these directly.
-
-##     def __init__(self):
-##         """"""
-##         pass
-
-    def IsOk(self):
-        """Return True if item is valid."""
-        pass
-
-    def Ok(self):
-        """Synonym for IsOk."""
-        pass

wxPython/wxPython/py/wxd/Validators.py

@@ -1,56 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Validator(EvtHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Clone(self):
-        """"""
-        pass
-
-    def GetWindow(self):
-        """"""
-        pass
-
-    def SetWindow(self, window):
-        """"""
-        pass
-
-
-class PyValidator(Validator):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self, _class, incref=True):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Window.py

@@ -1,850 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Window(EvtHandler):
-    """"""
-
-    def __init__(self, parent, id, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=0, name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def AcceptsFocus(self):
-        """"""
-        pass
-
-    def AddChild(self, child):
-        """"""
-        pass
-
-    def CaptureMouse(self):
-        """"""
-        pass
-
-    def Center(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CenterOnParent(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CenterOnScreen(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def Centre(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CentreOnParent(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CentreOnScreen(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def Clear(self):
-        """"""
-        pass
-
-    def ClientToScreen(self, pt):
-        """"""
-        pass
-
-    def ClientToScreenXY(self, x, y):
-        """"""
-        pass
-
-    def Close(self, force=False):
-        """"""
-        pass
-
-    def ConvertDialogPointToPixels(self, pt):
-        """"""
-        pass
-
-    def ConvertDialogSizeToPixels(self, sz):
-        """"""
-        pass
-
-    def ConvertPixelPointToDialog(self, pt):
-        """"""
-        pass
-
-    def ConvertPixelSizeToDialog(self, sz):
-        """"""
-        pass
-
-    def Create(self, parent, id, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=0, name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def DLG_PNT(self, win, point_or_x, y=None):
-        """"""
-        pass
-
-    def DLG_SZE(self, win, size_width, height=None):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def DestroyChildren(self):
-        """"""
-        pass
-
-    def DragAcceptFiles(self, accept):
-        """Windows only."""
-        pass
-
-    def Enable(self, enable):
-        """"""
-        pass
-
-    def FindWindowById(self, id):
-        """"""
-        pass
-
-    def FindWindowByName(self, name):
-        """"""
-        pass
-
-    def Fit(self):
-        """"""
-        pass
-
-    def FitInside(self):
-        """"""
-        pass
-
-    def Freeze(self):
-        """"""
-        pass
-
-    def GetAcceleratorTable(self):
-        """"""
-        pass
-
-    def GetAdjustedBestSize(self):
-        """"""
-        pass
-
-    def GetAutoLayout(self):
-        """"""
-        pass
-
-    def GetBackgroundColour(self):
-        """"""
-        pass
-
-    def GetBestSize(self):
-        """"""
-        pass
-
-    def GetBestVirtualSize(self):
-        """"""
-        pass
-
-    def GetBorder(self):
-        """"""
-        pass
-
-    def GetCaret(self):
-        """"""
-        pass
-
-    def GetCharHeight(self):
-        """"""
-        pass
-
-    def GetCharWidth(self):
-        """"""
-        pass
-
-    def GetChildren(self):
-        """"""
-        pass
-
-    def GetClientAreaOrigin(self):
-        """"""
-        pass
-
-    def GetClientRect(self):
-        """"""
-        pass
-
-    def GetClientSize(self):
-        """"""
-        pass
-
-    def GetClientSizeTuple(self):
-        """"""
-        pass
-
-    def GetConstraints(self):
-        """"""
-        pass
-
-    def GetContainingSizer(self):
-        """"""
-        pass
-
-    def GetCursor(self):
-        """"""
-        pass
-
-    def GetDefaultItem(self):
-        """"""
-        pass
-
-    def GetDropTarget(self):
-        """"""
-        pass
-
-    def GetEventHandler(self):
-        """"""
-        pass
-
-    def GetFont(self):
-        """"""
-        pass
-
-    def GetForegroundColour(self):
-        """"""
-        pass
-
-    def GetFullTextExtent(self):
-        """"""
-        pass
-
-    def GetGrandParent(self):
-        """"""
-        pass
-
-    def GetHandle(self):
-        """"""
-        pass
-
-    def GetHelpText(self):
-        """"""
-        pass
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetMaxSize(self):
-        """"""
-        pass
-
-    def GetName(self):
-        """"""
-        pass
-
-    def GetParent(self):
-        """"""
-        pass
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetPositionTuple(self):
-        """"""
-        pass
-
-    def GetRect(self):
-        """"""
-        pass
-
-    def GetScrollPos(self, orientation):
-        """"""
-        pass
-
-    def GetScrollRange(self, orientation):
-        """"""
-        pass
-
-    def GetScrollThumb(self, orientation):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def GetSizeTuple(self):
-        """"""
-        pass
-
-    def GetSizer(self):
-        """"""
-        pass
-
-    def GetTextExtent(self, string):
-        """"""
-        pass
-
-    def GetTitle(self):
-        """"""
-        pass
-
-    def GetToolTip(self):
-        """"""
-        pass
-
-    def GetUpdateRegion(self):
-        """"""
-        pass
-
-    def GetValidator(self):
-        """"""
-        pass
-
-    def GetVirtualSize(self):
-        """"""
-        pass
-
-    def GetVirtualSizeTuple(self):
-        """"""
-        pass
-
-    def GetWindowStyleFlag(self):
-        """"""
-        pass
-
-    def HasCapture(self):
-        """"""
-        pass
-
-    def HasScrollbar(self, orient):
-        """"""
-        pass
-
-    def Hide(self):
-        """"""
-        pass
-
-    def HitTest(self, pt):
-        """"""
-        pass
-
-    def InitDialog(self):
-        """"""
-        pass
-
-    def IsBeingDeleted(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsExposed(self, x, y, w=0, h=0):
-        """"""
-        pass
-
-    def IsExposedPoint(self, pt):
-        """"""
-        pass
-
-    def IsExposedRect(self, rect):
-        """"""
-        pass
-
-    def IsRetained(self):
-        """"""
-        pass
-
-    def IsShown(self):
-        """"""
-        pass
-
-    def IsTopLevel(self):
-        """"""
-        pass
-
-    def Layout(self):
-        """"""
-        pass
-
-    def LineDown(self):
-        """"""
-        pass
-
-    def LineUp(self):
-        """"""
-        pass
-
-    def LoadFromResource(self, parent, resourceName, resourceTable=wx.NULL):
-        """Only if USE_WX_RESOURCES."""
-        pass
-
-    def Lower(self):
-        """"""
-        pass
-
-    def MakeModal(self, flag=True):
-        """"""
-        pass
-
-    def Move(self, point, flags=wx.SIZE_USE_EXISTING):
-        """"""
-        pass
-
-    def MoveXY(self, x, y, flags=wx.SIZE_USE_EXISTING):
-        """"""
-        pass
-
-    def OnPaint(self, event):
-        """Windows only."""
-        pass
-
-    def PageDown(self):
-        """"""
-        pass
-
-    def PageUp(self):
-        """"""
-        pass
-
-    def PopEventHandler(self, deleteHandler=False):
-        """"""
-        pass
-
-    def PopupMenu(self, menu, pos):
-        """"""
-        pass
-
-    def PopupMenuXY(self, menu, x, y):
-        """"""
-        pass
-
-    def PushEventHandler(self, handler):
-        """"""
-        pass
-
-    def Raise(self):
-        """"""
-        pass
-
-    def Refresh(self, eraseBackground=True, rect=wx.NULL):
-        """"""
-        pass
-
-    def RefreshRect(self, rect):
-        """"""
-        pass
-
-    def ReleaseMouse(self):
-        """"""
-        pass
-
-    def RemoveChild(self, child):
-        """"""
-        pass
-
-    def RemoveEventHandler(self, handler):
-        """"""
-        pass
-
-    def Reparent(self, newParent):
-        """"""
-        pass
-
-    def ScreenToClient(self, pt):
-        """"""
-        pass
-
-    def ScreenToClientXY(self, x, y):
-        """"""
-        pass
-
-    def ScrollLines(self, lines):
-        """"""
-        pass
-
-    def ScrollPages(self, pages):
-        """"""
-        pass
-
-    def ScrollWindow(self, dx, dy, rect=wx.NULL):
-        """"""
-        pass
-
-    def SetAcceleratorTable(self, accel):
-        """"""
-        pass
-
-    def SetAutoLayout(self, autoLayout):
-        """"""
-        pass
-
-    def SetBackgroundColour(self, colour):
-        """"""
-        pass
-
-    def SetCaret(self, caret):
-        """"""
-        pass
-
-    def SetClientSize(self, size):
-        """"""
-        pass
-
-    def SetClientSizeWH(self, width, height):
-        """"""
-        pass
-
-    def SetConstraints(self, constraints):
-        """"""
-        pass
-
-    def SetContainingSizer(self, sizer):
-        """"""
-        pass
-
-    def SetCursor(self, cursor):
-        """"""
-        pass
-
-    def SetDefaultItem(self, btn):
-        """"""
-        pass
-
-    def SetDimensions(self):
-        """"""
-        pass
-
-    def SetDropTarget(self, target):
-        """"""
-        pass
-
-    def SetEventHandler(self, handler):
-        """"""
-        pass
-
-    def SetExtraStyle(self, exStyle):
-        """"""
-        pass
-
-    def SetFocus(self):
-        """"""
-        pass
-
-    def SetFocusFromKbd(self):
-        """"""
-        pass
-
-    def SetFont(self, font):
-        """"""
-        pass
-
-    def SetForegroundColour(self, colour):
-        """"""
-        pass
-
-    def SetHelpText(self, helpText):
-        """"""
-        pass
-
-    def SetHelpTextForId(self, text):
-        """"""
-        pass
-
-    def SetId(self, id):
-        """"""
-        pass
-
-    def SetLabel(self, label):
-        """"""
-        pass
-
-    def SetName(self, name):
-        """"""
-        pass
-
-    def SetPosition(self, pos, flags=wx.SIZE_USE_EXISTING):
-        """"""
-        pass
-
-    def SetRect(self, rect, sizeFlags=wx.SIZE_AUTO):
-        """"""
-        pass
-
-    def SetScrollPos(self, orientation, pos, refresh=True):
-        """"""
-        pass
-
-    def SetScrollbar(self, orientation, pos, thumbSize, range, refresh=True):
-        """"""
-        pass
-
-    def SetSize(self, x, y, width, height, sizeFlags=wx.SIZE_AUTO):
-        """"""
-        pass
-
-    def SetSizeHints(self, minW, minH, maxW=-1, maxH=-1, incW=-1, incH=-1):
-        """"""
-        pass
-
-    def SetSizer(self, sizer, deleteOld=True):
-        """"""
-        pass
-
-    def SetSizerAndFit(self, sizer, deleteOld=True):
-        """"""
-        pass
-
-    def SetTitle(self, title):
-        """"""
-        pass
-
-    def SetTmpDefaultItem(self, win):
-        """"""
-        pass
-
-    def SetToolTip(self, tooltip):
-        """"""
-        pass
-
-    def SetToolTipString(self, tip):
-        """"""
-        pass
-
-    def SetValidator(self, validator):
-        """"""
-        pass
-
-    def SetVirtualSize(self, size):
-        """"""
-        pass
-
-    def SetVirtualSizeHints(self, minW, minH, maxW=-1, maxH=-1):
-        """"""
-        pass
-
-    def SetVirtualSizeWH(self, x, y):
-        """"""
-        pass
-
-    def SetWindowStyle(self, style):
-        """"""
-        pass
-
-    def SetWindowStyleFlag(self, style):
-        """"""
-        pass
-
-    def Show(self, show=True):
-        """"""
-        pass
-
-    def Thaw(self):
-        """"""
-        pass
-
-    def TransferDataFromWindow(self):
-        """"""
-        pass
-
-    def TransferDataToWindow(self):
-        """"""
-        pass
-
-    def UnsetConstraints(self, constraints):
-        """"""
-        pass
-
-    def Update(self):
-        """"""
-        pass
-
-    def UpdateWindowUI(self):
-        """"""
-        pass
-
-    def Validate(self):
-        """"""
-        pass
-
-    def WarpPointer(self, x, y):
-        """"""
-        pass
-
-
-class PyWindow(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_AcceptsFocus(self):
-        """"""
-        pass
-
-    def base_AcceptsFocusFromKeyboard(self):
-        """"""
-        pass
-
-    def base_AddChild(self):
-        """"""
-        pass
-
-    def base_DoGetBestSize(self):
-        """"""
-        pass
-
-    def base_DoGetClientSize(self):
-        """"""
-        pass
-
-    def base_DoGetPosition(self):
-        """"""
-        pass
-
-    def base_DoGetSize(self):
-        """"""
-        pass
-
-    def base_DoGetVirtualSize(self):
-        """"""
-        pass
-
-    def base_DoMoveWindow(self):
-        """"""
-        pass
-
-    def base_DoSetClientSize(self):
-        """"""
-        pass
-
-    def base_DoSetSize(self):
-        """"""
-        pass
-
-    def base_DoSetVirtualSize(self):
-        """"""
-        pass
-
-    def base_GetMaxSize(self):
-        """"""
-        pass
-
-    def base_InitDialog(self):
-        """"""
-        pass
-
-    def base_RemoveChild(self):
-        """"""
-        pass
-
-    def base_TransferDataFromWindow(self):
-        """"""
-        pass
-
-    def base_TransferDataToWindow(self):
-        """"""
-        pass
-
-    def base_Validate(self):
-        """"""
-        pass
-
-
-class TopLevelWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetIcon(self):
-        """"""
-        pass
-
-    def GetTitle(self):
-        """"""
-        pass
-
-    def Iconize(self):
-        """"""
-        pass
-
-    def IsFullScreen(self):
-        """"""
-        pass
-
-    def IsIconized(self):
-        """"""
-        pass
-
-    def IsMaximized(self):
-        """"""
-        pass
-
-    def Maximize(self):
-        """"""
-        pass
-
-    def Restore(self):
-        """"""
-        pass
-
-    def SetIcon(self):
-        """"""
-        pass
-
-    def SetIcons(self):
-        """"""
-        pass
-
-    def SetTitle(self):
-        """"""
-        pass
-
-    def ShowFullScreen(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/__init__.py

@@ -1 +0,0 @@
-# Orbtech python package.

wxPython/wxPython/py/wxd/d_stc.py

@@ -1,17 +0,0 @@
-"""Decorator utility for documentation and shell scripting.
-
-When you import stc from this module, all of the classes get decorated
-with docstrings from our decoration class definitions.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import stc
-
-import stc_
-
-import decorator
-
-decorator.decorate(real=stc, decoration=stc_)

wxPython/wxPython/py/wxd/d_wx.py

@@ -1,17 +0,0 @@
-"""Decorator utility for documentation and shell scripting.
-
-When you import wx from this module, all of the classes get decorated
-with docstrings from our decoration class definitions.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-import wx_
-
-import decorator
-
-decorator.decorate(real=wx, decoration=wx_)

wxPython/wxPython/py/wxd/decorator.py

@@ -1,93 +0,0 @@
-"""Decorator utility for documentation and shell scripting."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-import inspect
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-def decorate(real, decoration):
-    """Decorate real module with docstrings from decoration module."""
-    realdict = real.__dict__
-    for item in decoration.__dict__.values():
-        if inspect.isclass(item):
-            decorateClass(item, realdict)
-        elif inspect.isfunction(item):
-            decorateFunction(item, realdict)
-
-def decorateClass(item, realdict):
-    classname = item.__name__
-    if not classname.startswith('wx'):
-        classname = 'wx' + classname
-    try:
-        wxclass = realdict[classname]
-    except:
-        # print classname
-        pass
-    else:
-        if item.__doc__:
-            wxclass.__doc__ = item.__doc__
-        # Get attributes from only the item's local dictionary!
-        for attrname, attr in item.__dict__.items():
-            # If the attribute has a docstring, and the wx class has a
-            # matching attribute.
-            if hasattr(attr, '__doc__') and hasattr(wxclass, attrname):
-                if inspect.isfunction(attr):
-                    # Class methods are functions.
-                    doc = getdoc(attr, drop=True)
-                    # Is getattr() okay, or do we want to only look in
-                    # the wxclass.__dict__ and wxclassPtr.__dict__?
-                    wxattr = getattr(wxclass, attrname)
-                    # Our class code may be defined incorrectly, and
-                    # the wxattr may not actually be a class method,
-                    # but that's okay because the following attempt
-                    # will simply fail.
-                    try:
-                        func = wxattr.im_func
-                        func.__doc__ = doc
-                    except:
-                        pass
-
-def decorateFunction(item, realdict):
-    funcname = item.__name__
-    if funcname in realdict.keys():
-        func = realdict[funcname]
-        doc = getdoc(item, drop=False)
-        try:
-            # Built-in functions have a read-only docstring. :-(
-            func.__doc__ = doc
-        except:
-            # print funcname
-            pass
-
-def getdoc(attr, drop=False):
-    """Return a docstring for attr, which should be a method."""
-    doc = ''
-    if attr.__doc__:
-        doc = inspect.getdoc(attr).strip()
-    name = attr.__name__
-    # tip is a string with name(argspec), like: "SetLabel(label)"
-    tip = ''
-    argspec = apply(inspect.formatargspec, inspect.getargspec(attr))
-    # The first parameter to a method is a reference to an instance,
-    # usually coded as "self", and is usually passed automatically by
-    # Python and therefore we want to drop it.
-    temp = argspec.split(',')
-    if len(temp) == 1:  # No other arguments.
-        argspec = '()'
-    elif drop:  # Drop the first argument.
-        argspec = '(' + ','.join(temp[1:]).lstrip()
-    else:
-        argspec = ','.join(temp).lstrip()
-    tip = name + argspec
-    firstline = doc.split('\n')[0].lstrip()
-    if tip != firstline:
-        doc = '%s\n\n%s' % (tip, doc)
-    return doc

wxPython/wxPython/py/wxd/gen.py

@@ -1,71 +0,0 @@
-
-import inspect
-from wxPython import wx
-
-
-def scan():
-    d = wx.__dict__
-    newd = {}
-    keys = d.keys()
-    keys.sort()
-    for key in keys:
-        if key.endswith('Ptr'):
-            # Skip
-            pass
-        elif key+'Ptr' in keys:
-            # Rename
-            newd[key] = d[key+'Ptr']
-        else:
-            # Include as is
-            newd[key] = d[key]
-    d = newd
-    keys = d.keys()
-    keys.sort()
-    for key in keys:
-        value = d[key]
-        if inspect.isclass(value):
-            # genClass(value)
-            pass
-        elif callable(value):
-            genFunction(value)
-            pass
-        else:
-            # print type(value), value            
-            pass
-
-
-def genClass(cls):
-    sp4 = ' ' * 4
-    name = cls.__name__
-    if name.endswith('Ptr'):
-        name = name[:-3]
-##     if name != 'wxNotebook':
-##         return
-    parent = ''
-    if cls.__bases__:
-        parent = cls.__bases__[0].__name__
-        if parent.endswith('Ptr'):
-            parent = parent[:-3]
-        parent = '(%s)' % parent
-    items = cls.__dict__.keys()
-    items.sort()
-    print
-    print 'class %s%s:' % (name, parent)
-    print sp4 + '""""""'
-    print
-    for item in items:
-        attr = cls.__dict__[item]
-        if inspect.isfunction(attr):
-            print sp4 + 'def ' + item + '(self):'
-            print sp4 + sp4 + '""""""'
-            print sp4 + sp4 + 'pass'
-            print
-
-
-def genFunction(func):
-    sp4 = ' ' * 4
-    name = func.__name__
-    print 'def %s():' % name
-    print sp4 + '""""""'
-    print sp4 + 'pass'
-    print

wxPython/wxPython/py/wxd/wx_.py

@@ -1,66 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-
-Information contained in this module, and all modules imported by this
-module, is covered by the wxWindows Free Documentation Licence.  See
-the LICENSE.txt file for details.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-_topics = {
-    'Accelerators': None,
-    'App': None,
-    'Base': None,
-    'ClipDragDrop': None,
-    'Config': None,
-    'Controls': None,
-    'DataStructures': None,
-    'DateTime': None,
-    'Dialogs': None,
-    'Drawing': None,
-    'Errors': None,
-    'EventFunctions': None,
-    'Events': None,
-    'FileSystem': None,
-    'Frames': None,
-    'Functions': None,
-    'Help': None,
-    'ImageHandlers': None,
-    'Joystick': None,
-    'LayoutConstraints': None,
-    'Logging': None,
-    'Menus': None,
-    'MimeTypes': None,
-    'Misc': None,
-    'Panel': None,
-    'Printing': None,
-    'Process': None,
-    'SashSplitter': None,
-    'Sizers': None,
-    'Streams': None,
-    'Threading': None,
-    'ToolBar': None,
-    'Tree': None,
-    'Validators': None,
-    'Window': None,
-    }
-
-for topic in _topics.keys():
-    _topics[topic] = __import__(topic, globals())
-    exec 'from %s import *' % topic
-
-del topic  # Cleanup the namespace.
-
-try:
-    del wx  # Cleanup any module that imports Parameters as wx.
-except:
-    pass